Remove explorer's proto fuzzer and proto dependencies (#4731)

As part of migrating to the latest bazel configurations in #4729, I'm
running into proto toolchain issues. For example:
"Error: <target @@protobuf+//:cc_toolchain> (rule
'proto_lang_toolchain') doesn't contain declared provider
'ProtoLangToolchainInfo'"

Although we may eventually want more use of proto, right now the only
use is for the explorer fuzzer. The explorer codebase is essentially
frozen, so continuing to run it isn't gaining us much (in fact, we've
already disabled autofuzzing for it).

So, rather than trying to fix the proto setup, this change:

1. Deletes `explorer/fuzzing`
2. Removes proto portions of `testing/fuzzing`, which were only in-use
by the explorer
3. Removes some ancillary proto support, which would otherwise break
from the bazel changes and would be difficult to validate as "still
working"

This change is partly isolated in order to make it easier to revive bits
of (3).

.bazelrc

@@ -62,16 +62,6 @@ build --host_per_file_copt=external/.*\.(c|cc|cpp|cxx)$@-w
 build --per_file_copt=utils/treesitter/_treesitter.tree_sitter/.*\.c$@-w
 build --host_per_file_copt=utils/treesitter/_treesitter.tree_sitter/.*\.c$@-w
 
-# The `cc_proto_library` rule doesn't allow providing `copts`:
-# https://github.com/bazelbuild/bazel/issues/22610
-#
-# We unfortunately need to work around issues with `-Wmissing-prototypes` in
-# generated protobuf code, so pass the `copt` manually here. The warning issue
-# is likely part of:
-# https://github.com/llvm/llvm-project/issues/94138
-build --per_file_copt=.*\.pb\.cc$@-Wno-missing-prototypes
-build --host_per_file_copt=.*\.pb\.cc$@-Wno-missing-prototypes
-
 # Default dynamic linking to off. While this can help build performance in some
 # edge cases with very large linked executables and a slow linker, between using
 # fast linkers on all platforms (LLD and the Apple linker), as well as having

.pre-commit-config.yaml

@@ -85,7 +85,7 @@ repos:
       - id: clang-format
         name: clang-format
         entry: clang-format
-        types_or: [c++, proto, def]
+        types_or: [c++, def]
         language: python
         args: ['-i']
         additional_dependencies: ['clang-format==17.0.1']
@@ -184,7 +184,7 @@ repos:
             Exceptions. See /LICENSE for license information.
             SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
           - --custom_format
-          - '\.(carbon|c|json|proto|scss|ypp)(\.tmpl)?$'
+          - '\.(carbon|c|json|scss|ypp)(\.tmpl)?$'
           - ''
           - '// '
           - ''

MODULE.bazel

@@ -69,18 +69,6 @@ bazel_dep(name = "rules_bison", version = "0.2.2")
 bazel_dep(name = "rules_flex", version = "0.2.1")
 bazel_dep(name = "rules_m4", version = "0.2.3")
 bazel_dep(name = "rules_cc", version = "0.0.9")
-bazel_dep(name = "rules_proto", version = "6.0.2")
-bazel_dep(name = "protobuf", version = "27.1")
-
-libprotobuf_mutator_version = "1.3"
-
-http_archive(
-    name = "com_google_libprotobuf_mutator",
-    build_file = "@//:third_party/libprotobuf_mutator/BUILD.txt",
-    sha256 = "1ee3473a6b0274494fce599539605bb19305c0efadc62b58d645812132c31baa",
-    strip_prefix = "libprotobuf-mutator-{0}".format(libprotobuf_mutator_version),
-    urls = ["https://github.com/google/libprotobuf-mutator/archive/v{0}.tar.gz".format(libprotobuf_mutator_version)],
-)
 
 bazel_dep(name = "bazel_clang_tidy", dev_dependency = True)
 git_override(

MODULE.bazel.lock

@@ -18,7 +18,6 @@
     "https://bcr.bazel.build/modules/bazel_features/1.1.1/MODULE.bazel": "27b8c79ef57efe08efccbd9dd6ef70d61b4798320b8d3c134fd571f78963dbcd",
     "https://bcr.bazel.build/modules/bazel_features/1.11.0/MODULE.bazel": "f9382337dd5a474c3b7d334c2f83e50b6eaedc284253334cf823044a26de03e8",
     "https://bcr.bazel.build/modules/bazel_features/1.11.0/source.json": "c9320aa53cd1c441d24bd6b716da087ad7e4ff0d9742a9884587596edfe53015",
-    "https://bcr.bazel.build/modules/bazel_features/1.4.1/MODULE.bazel": "e45b6bb2350aff3e442ae1111c555e27eac1d915e77775f6fdc4b351b758b5d7",
     "https://bcr.bazel.build/modules/bazel_features/1.9.1/MODULE.bazel": "8f679097876a9b609ad1f60249c49d68bfab783dd9be012faf9d82547b14815a",
     "https://bcr.bazel.build/modules/bazel_skylib/1.0.3/MODULE.bazel": "bcb0fd896384802d1ad283b4e4eb4d718eebd8cb820b0a2c3a347fb971afd9d8",
     "https://bcr.bazel.build/modules/bazel_skylib/1.1.1/MODULE.bazel": "1add3e7d93ff2e6998f9e118022c84d163917d912f5afafb3058e3d2f1545b5e",
@@ -53,8 +52,7 @@
     "https://bcr.bazel.build/modules/platforms/0.0.9/MODULE.bazel": "4a87a60c927b56ddd67db50c89acaa62f4ce2a1d2149ccb63ffd871d5ce29ebc",
     "https://bcr.bazel.build/modules/protobuf/21.7/MODULE.bazel": "a5a29bb89544f9b97edce05642fac225a808b5b7be74038ea3640fae2f8e66a7",
     "https://bcr.bazel.build/modules/protobuf/26.0/MODULE.bazel": "8402da964092af40097f4a205eec2a33fd4a7748dc43632b7d1629bfd9a2b856",
-    "https://bcr.bazel.build/modules/protobuf/27.1/MODULE.bazel": "703a7b614728bb06647f965264967a8ef1c39e09e8f167b3ca0bb1fd80449c0d",
-    "https://bcr.bazel.build/modules/protobuf/27.1/source.json": "11a2567425ffebb89ff59e94fc8a55bc78a418d52a4cc415069ce7c793571352",
+    "https://bcr.bazel.build/modules/protobuf/26.0/source.json": "1d712839d9a0ad0948046b84bdf1619a0abd4d3a0a9d8ce6192b919a7c18df40",
     "https://bcr.bazel.build/modules/protobuf/3.19.0/MODULE.bazel": "6b5fbb433f760a99a22b18b6850ed5784ef0e9928a72668b66e4d7ccd47db9b0",
     "https://bcr.bazel.build/modules/protobuf/3.19.6/MODULE.bazel": "9233edc5e1f2ee276a60de3eaa47ac4132302ef9643238f23128fea53ea12858",
     "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1.bzl.1/MODULE.bazel": "1ef2994c097ee88f8f7ae8fbf991aaefb0603b2540fe575eca14943bc9f220a6",
@@ -81,7 +79,6 @@
     "https://bcr.bazel.build/modules/rules_fuzzing/0.5.1/MODULE.bazel": "e6555740cac87ff14367e998bb4a417cf17d7953f81b161afcb679ddc5034b94",
     "https://bcr.bazel.build/modules/rules_fuzzing/0.5.1/source.json": "dca9ea70f034bac9650d9b679b8bb2d192958898027636361a95822fff8bc5a0",
     "https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74",
-    "https://bcr.bazel.build/modules/rules_java/5.3.5/MODULE.bazel": "a4ec4f2db570171e3e5eb753276ee4b389bae16b96207e9d3230895c99644b86",
     "https://bcr.bazel.build/modules/rules_java/6.5.2/MODULE.bazel": "1d440d262d0e08453fa0c4d8f699ba81609ed0e9a9a0f02cd10b3e7942e61e31",
     "https://bcr.bazel.build/modules/rules_java/7.6.5/MODULE.bazel": "481164be5e02e4cab6e77a36927683263be56b7e36fef918b458d7a8a1ebadb1",
     "https://bcr.bazel.build/modules/rules_java/7.6.5/source.json": "a805b889531d1690e3c72a7a7e47a870d00323186a9904b36af83aa3d053ee8d",
@@ -100,8 +97,7 @@
     "https://bcr.bazel.build/modules/rules_proto/4.0.0/MODULE.bazel": "a7a7b6ce9bee418c1a760b3d84f83a299ad6952f9903c67f19e4edd964894e06",
     "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/MODULE.bazel": "e8dff86b0971688790ae75528fe1813f71809b5afd57facb44dad9e8eca631b7",
     "https://bcr.bazel.build/modules/rules_proto/6.0.0-rc1/MODULE.bazel": "1e5b502e2e1a9e825eef74476a5a1ee524a92297085015a052510b09a1a09483",
-    "https://bcr.bazel.build/modules/rules_proto/6.0.2/MODULE.bazel": "ce916b775a62b90b61888052a416ccdda405212b6aaeb39522f7dc53431a5e73",
-    "https://bcr.bazel.build/modules/rules_proto/6.0.2/source.json": "17a2e195f56cb28d6bbf763e49973d13890487c6945311ed141e196fb660426d",
+    "https://bcr.bazel.build/modules/rules_proto/6.0.0-rc1/source.json": "8d8448e71706df7450ced227ca6b3812407ff5e2ccad74a43a9fbe79c84e34e0",
     "https://bcr.bazel.build/modules/rules_python/0.10.2/MODULE.bazel": "cc82bc96f2997baa545ab3ce73f196d040ffb8756fd2d66125a530031cd90e5f",
     "https://bcr.bazel.build/modules/rules_python/0.20.0/MODULE.bazel": "bfe14d17f20e3fe900b9588f526f52c967a6f281e47a1d6b988679bd15082286",
     "https://bcr.bazel.build/modules/rules_python/0.22.1/MODULE.bazel": "26114f0c0b5e93018c0c066d6673f1a2c3737c7e90af95eff30cfee38d0bbac7",

bazel/cc_toolchains/clang_cc_toolchain_config.bzl

@@ -156,7 +156,6 @@ def _impl(ctx):
                             "--system-header-prefix=clang-tools-extra/",
                             "--system-header-prefix=clang/",
                             "--system-header-prefix=gmock/",
-                            "--system-header-prefix=google/protobuf/",
                             "--system-header-prefix=gtest/",
                             "--system-header-prefix=libfuzzer/",
                             "--system-header-prefix=llvm/",

bazel/check_deps/check_non_test_cc_deps.py

@@ -92,7 +92,6 @@ for dep in deps:
     # message.
     if repo_base in (
         "@google_benchmark",
-        "@protobuf",
         "@abseil-cpp",
         "@googletest",
     ):

explorer/fuzzing/BUILD

@@ -1,129 +0,0 @@
-# Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-# Exceptions. See /LICENSE for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library", "cc_test")
-load("//testing/fuzzing:rules.bzl", "cc_fuzz_test")
-
-cc_library(
-    name = "ast_to_proto_lib",
-    testonly = 1,
-    srcs = ["ast_to_proto.cpp"],
-    hdrs = ["ast_to_proto.h"],
-    # Running clang-tidy is slow, and explorer is currently feature frozen, so
-    # don't spend time linting it.
-    tags = ["no-clang-tidy"],
-    deps = [
-        "//explorer/ast",
-        "//testing/fuzzing:carbon_cc_proto",
-        "@llvm-project//llvm:Support",
-    ],
-)
-
-cc_binary(
-    name = "ast_to_proto",
-    testonly = 1,
-    srcs = ["ast_to_proto_main.cpp"],
-    # Running clang-tidy is slow, and explorer is currently feature frozen, so
-    # don't spend time linting it.
-    tags = ["no-clang-tidy"],
-    deps = [
-        ":ast_to_proto_lib",
-        "//common:bazel_working_dir",
-        "//common:error",
-        "//explorer/ast",
-        "//explorer/base:arena",
-        "//explorer/syntax",
-        "//testing/fuzzing:carbon_cc_proto",
-        "@protobuf//:protobuf_headers",
-    ],
-)
-
-cc_test(
-    name = "ast_to_proto_test",
-    size = "small",
-    srcs = ["ast_to_proto_test.cpp"],
-    args = [
-        "$(locations //explorer:standard_libraries)",
-        "$(locations //explorer:carbon_files)",
-    ],
-    data = [
-        "//explorer:carbon_files",
-        "//explorer:standard_libraries",
-    ],
-    # Running clang-tidy is slow, and explorer is currently feature frozen, so
-    # don't spend time linting it.
-    tags = ["no-clang-tidy"],
-    deps = [
-        ":ast_to_proto_lib",
-        "//explorer/syntax",
-        "//testing/base:test_raw_ostream",
-        "//testing/fuzzing:carbon_cc_proto",
-        "//testing/fuzzing:proto_to_carbon_lib",
-        "@googletest//:gtest",
-        "@protobuf//:differencer",
-        "@protobuf//:protobuf_headers",
-    ],
-)
-
-cc_library(
-    name = "fuzzer_util",
-    testonly = 1,
-    srcs = ["fuzzer_util.cpp"],
-    hdrs = ["fuzzer_util.h"],
-    # Running clang-tidy is slow, and explorer is currently feature frozen, so
-    # don't spend time linting it.
-    tags = ["no-clang-tidy"],
-    deps = [
-        "//common:check",
-        "//common:error",
-        "//explorer/ast",
-        "//explorer/parse_and_execute",
-        "//testing/fuzzing:carbon_cc_proto",
-        "//testing/fuzzing:proto_to_carbon_lib",
-        "@bazel_tools//tools/cpp/runfiles",
-        "@llvm-project//llvm:Support",
-        "@protobuf//:protobuf_headers",
-    ],
-)
-
-cc_test(
-    name = "fuzzer_util_test",
-    size = "small",
-    srcs = ["fuzzer_util_test.cpp"],
-    data = [
-        "//explorer:standard_libraries",
-    ],
-    # Running clang-tidy is slow, and explorer is currently feature frozen, so
-    # don't spend time linting it.
-    tags = ["no-clang-tidy"],
-    deps = [
-        ":fuzzer_util",
-        "//testing/base:gtest_main",
-        "//testing/fuzzing:proto_to_carbon_lib",
-        "@googletest//:gtest",
-        "@llvm-project//llvm:Support",
-        "@protobuf//:protobuf_headers",
-    ],
-)
-
-cc_fuzz_test(
-    name = "explorer_fuzzer",
-    size = "small",
-    srcs = ["explorer_fuzzer.cpp"],
-    # Uses a macro-based fuzzing library that triggers this warning. And
-    # explorer is currently feature frozen, so just disable the warning.
-    copts = ["-Wno-missing-prototypes"],
-    corpus = glob(["fuzzer_corpus/*"]),
-    shard_count = 8,
-    tags = [
-        "no-clang-tidy",
-        "proto-fuzzer",
-    ],
-    deps = [
-        ":fuzzer_util",
-        "//common:error",
-        "@com_google_libprotobuf_mutator//:libprotobuf_mutator",
-        "@llvm-project//llvm:Support",
-    ],
-)

explorer/fuzzing/README.md

@@ -1,115 +0,0 @@
-# Explorer structured fuzzer
-
-<!--
-Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-Exceptions. See /LICENSE for license information.
-SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
--->
-
-## Overview
-
-Fuzz testing is based on generating a large amount of random inputs for a
-software component in order to trigger bugs and unexpected behavior. Basic
-fuzzing uses randomly generated arrays of bytes as inputs, which works great for
-some applications but is problematic for testing the logic that operates on
-highly structured data, as most random inputs are immediately rejected as
-invalid before any interesting parts of the code get a chance to run.
-
-Structured fuzzing addresses this issue by ensuring the randomly generated data
-is itself structured, and as such has a high chance of presenting a valid input.
-
-`explorer_fuzzer` is a structured fuzzer based on
-[libprotobuf-mutator](https://github.com/google/libprotobuf-mutator), which is a
-library to randomly mutate
-[protobuffers](https://github.com/protocolbuffers/protobuf).
-
-The input to the fuzzer is an instance of `Carbon::Fuzzing::Carbon` proto
-randomly generated by the `libprotobuf-mutator` framework. `explorer_fuzzer`
-converts the proto to a Carbon source code string, and tries to parse and
-execute the code using `explorer` implementation.
-
-## Fuzzer data format
-
-`libprotobuf-mutator` supports fuzzer inputs in either text or binary protocol
-buffer format. `explorer_fuzzer` uses text proto format with `Carbon` proto
-message definition in `testing/fuzzing/carbon.proto`.
-
-## Incorporating AST changes into the fuzzer
-
-Fuzzer AST representation in [carbon.proto](/testing/fuzzing/carbon.proto) needs
-to be updated when changes are made to the AST, like adding a new AST node
-classes or changing relevant data members of existing nodes.
-
-[ast_to_proto_test](ast_to_proto_test.cpp) normally should not require direct
-changes, as tests work off of Carbon test files in
-[testdata](/explorer/testdata).
-
-To incorporate AST changes into fuzzing logic:
-
-1. Add appropriate AST information to
-   [carbon.proto](/testing/fuzzing/carbon.proto). Use existing similar cases as
-   examples.
-
-2. Modify [proto_to_carbon.cpp](/testing/fuzzing/proto_to_carbon.cpp) which
-   handles printing of a Carbon proto instance as a Carbon source string. For
-   example, add code to print newly introduced proto fields.
-
-3. Add logic to populate the proto to
-   [ast_to_proto.cpp](/explorer/fuzzing/ast_to_proto.cpp).
-
-4. Make sure `bazel test //explorer/fuzzing:ast_to_proto_test` passes with the
-   new changes.
-
-## Running the fuzzer
-
-The fuzzer can be run in 'unit test' mode, where the fuzzer executes on each
-input file from the `fuzzer_corpus/` folder, or in 'fuzzing' mode, where the
-fuzzer will keep generating random inputs and executing the logic on them until
-a crash is triggered, or forever in a bug-free program ;).
-
-To run in 'unit test' mode:
-
-```bash
-bazel test //explorer/fuzzing:explorer_fuzzer
-```
-
-To run in 'fuzzing' mode:
-
-```bash
-bazel build --config=fuzzer //explorer/fuzzing:explorer_fuzzer.full_corpus
-
-bazel-bin/explorer/fuzzing/explorer_fuzzer.full_corpus
-```
-
-## Investigating a crash
-
-Typically it's going to be easiest to run explorer on the problematic carbon
-program directly. You can do this with:
-
-```bash
-# Convert a specific fuzzer test to a source file
-bazel run //testing/fuzzing:proto_to_carbon -- explorer/fuzzing/fuzzer_corpus/abcd1234 > crash.carbon
-# Or convert the crash to a source file.
-bazel run //testing/fuzzing:proto_to_carbon -- /tmp/crash.textproto > crash.carbon
-
-# Run explorer on the crash.
-bazel run //explorer -- crash.carbon
-```
-
-It's also possible to run the fuzzer on a single input:
-
-```bash
-bazel-bin/explorer/fuzzing/explorer_fuzzer.full_corpus /tmp/crash.textproto
-```
-
-## Generating new fuzzer corpus entries
-
-The ability of the fuzzing framework to generate 'interesting' inputs can be
-improved by providing 'seed' inputs known as the fuzzer corpus. The inputs need
-to be a `Fuzzing::Carbon` text proto.
-
-To generate a text proto from Carbon source:
-
-```bash
-bazel run //explorer/fuzzing:ast_to_proto -- /tmp/crash.carbon > crash.textproto
-```

explorer/fuzzing/ast_to_proto.cpp

@@ -1,869 +0,0 @@
-// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-// Exceptions. See /LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include "explorer/fuzzing/ast_to_proto.h"
-
-#include <optional>
-
-#include "explorer/ast/declaration.h"
-#include "explorer/ast/expression.h"
-#include "llvm/Support/Casting.h"
-
-namespace Carbon::Testing {
-
-using ::llvm::cast;
-using ::llvm::dyn_cast;
-using ::llvm::isa;
-
-static auto ExpressionToProto(const Expression& expression)
-    -> Fuzzing::Expression;
-static auto PatternToProto(const Pattern& pattern) -> Fuzzing::Pattern;
-static auto StatementToProto(const Statement& statement) -> Fuzzing::Statement;
-static auto DeclarationToProto(const Declaration& declaration)
-    -> Fuzzing::Declaration;
-
-static auto LibraryNameToProto(const LibraryName& library_name)
-    -> Fuzzing::LibraryName {
-  Fuzzing::LibraryName library_name_proto;
-  library_name_proto.set_package_name(library_name.package);
-  if (!library_name.path.empty()) {
-    library_name_proto.set_path(library_name.path);
-  }
-  return library_name_proto;
-}
-
-static auto OperatorToProtoEnum(const Operator op)
-    -> Fuzzing::OperatorExpression::Operator {
-  switch (op) {
-    case Operator::AddressOf:
-      return Fuzzing::OperatorExpression::AddressOf;
-    case Operator::As:
-      return Fuzzing::OperatorExpression::As;
-    case Operator::Deref:
-      return Fuzzing::OperatorExpression::Deref;
-    case Operator::Neg:
-      return Fuzzing::OperatorExpression::Neg;
-    case Operator::Not:
-      return Fuzzing::OperatorExpression::Not;
-    case Operator::Ptr:
-      return Fuzzing::OperatorExpression::Ptr;
-    case Operator::Add:
-      return Fuzzing::OperatorExpression::Add;
-    case Operator::And:
-      return Fuzzing::OperatorExpression::And;
-    case Operator::Eq:
-      return Fuzzing::OperatorExpression::Eq;
-    case Operator::NotEq:
-      return Fuzzing::OperatorExpression::NotEq;
-    case Operator::Less:
-      return Fuzzing::OperatorExpression::Less;
-    case Operator::LessEq:
-      return Fuzzing::OperatorExpression::LessEq;
-    case Operator::Greater:
-      return Fuzzing::OperatorExpression::Greater;
-    case Operator::GreaterEq:
-      return Fuzzing::OperatorExpression::GreaterEq;
-    case Operator::Mul:
-      return Fuzzing::OperatorExpression::Mul;
-    case Operator::Div:
-      return Fuzzing::OperatorExpression::Div;
-    case Operator::Mod:
-      return Fuzzing::OperatorExpression::Mod;
-    case Operator::Or:
-      return Fuzzing::OperatorExpression::Or;
-    case Operator::Sub:
-      return Fuzzing::OperatorExpression::Sub;
-    case Operator::BitwiseAnd:
-      return Fuzzing::OperatorExpression::BitwiseAnd;
-    case Operator::BitwiseOr:
-      return Fuzzing::OperatorExpression::BitwiseOr;
-    case Operator::BitwiseXor:
-      return Fuzzing::OperatorExpression::BitwiseXor;
-    case Operator::BitShiftLeft:
-      return Fuzzing::OperatorExpression::BitShiftLeft;
-    case Operator::BitShiftRight:
-      return Fuzzing::OperatorExpression::BitShiftRight;
-    case Operator::Complement:
-      return Fuzzing::OperatorExpression::Complement;
-  }
-}
-
-static auto AssignOperatorToProtoEnum(const AssignOperator op)
-    -> Fuzzing::AssignStatement::Operator {
-  switch (op) {
-    case AssignOperator::Plain:
-      return Fuzzing::AssignStatement::Plain;
-    case AssignOperator::Add:
-      return Fuzzing::AssignStatement::Add;
-    case AssignOperator::And:
-      return Fuzzing::AssignStatement::And;
-    case AssignOperator::Mul:
-      return Fuzzing::AssignStatement::Mul;
-    case AssignOperator::Div:
-      return Fuzzing::AssignStatement::Div;
-    case AssignOperator::Mod:
-      return Fuzzing::AssignStatement::Mod;
-    case AssignOperator::Or:
-      return Fuzzing::AssignStatement::Or;
-    case AssignOperator::ShiftLeft:
-      return Fuzzing::AssignStatement::ShiftLeft;
-    case AssignOperator::ShiftRight:
-      return Fuzzing::AssignStatement::ShiftRight;
-    case AssignOperator::Sub:
-      return Fuzzing::AssignStatement::Sub;
-    case AssignOperator::Xor:
-      return Fuzzing::AssignStatement::Xor;
-  }
-}
-
-static auto FieldInitializerToProto(const FieldInitializer& field)
-    -> Fuzzing::FieldInitializer {
-  Fuzzing::FieldInitializer field_proto;
-  field_proto.set_name(field.name());
-  *field_proto.mutable_expression() = ExpressionToProto(field.expression());
-  return field_proto;
-}
-
-static auto TupleLiteralExpressionToProto(const TupleLiteral& tuple_literal)
-    -> Fuzzing::TupleLiteralExpression {
-  Fuzzing::TupleLiteralExpression tuple_literal_proto;
-  for (Nonnull<const Expression*> field : tuple_literal.fields()) {
-    *tuple_literal_proto.add_fields() = ExpressionToProto(*field);
-  }
-  return tuple_literal_proto;
-}
-
-static auto ExpressionToProto(const Expression& expression)
-    -> Fuzzing::Expression {
-  Fuzzing::Expression expression_proto;
-  switch (expression.kind()) {
-    case ExpressionKind::BaseAccessExpression:
-    case ExpressionKind::ValueLiteral: {
-      // This does not correspond to source syntax.
-      break;
-    }
-
-    case ExpressionKind::BuiltinConvertExpression: {
-      expression_proto = ExpressionToProto(
-          *cast<BuiltinConvertExpression>(expression).source_expression());
-      break;
-    }
-
-    case ExpressionKind::CallExpression: {
-      const auto& call = cast<CallExpression>(expression);
-      auto* call_proto = expression_proto.mutable_call();
-      *call_proto->mutable_function() = ExpressionToProto(call.function());
-      *call_proto->mutable_argument() = ExpressionToProto(call.argument());
-      break;
-    }
-
-    case ExpressionKind::FunctionTypeLiteral: {
-      const auto& fun_type = cast<FunctionTypeLiteral>(expression);
-      auto* fun_type_proto = expression_proto.mutable_function_type();
-      *fun_type_proto->mutable_parameter() =
-          TupleLiteralExpressionToProto(fun_type.parameter());
-      *fun_type_proto->mutable_return_type() =
-          ExpressionToProto(fun_type.return_type());
-      break;
-    }
-
-    case ExpressionKind::SimpleMemberAccessExpression: {
-      const auto& simple_member_access =
-          cast<SimpleMemberAccessExpression>(expression);
-      if (isa<DotSelfExpression>(simple_member_access.object())) {
-        // The parser rewrites `.Foo` into `.Self.Foo`. Undo this
-        // transformation.
-        auto* designator_proto = expression_proto.mutable_designator();
-        designator_proto->set_name(simple_member_access.member_name());
-        break;
-      }
-      auto* simple_member_access_proto =
-          expression_proto.mutable_simple_member_access();
-      simple_member_access_proto->set_field(simple_member_access.member_name());
-      *simple_member_access_proto->mutable_object() =
-          ExpressionToProto(simple_member_access.object());
-      break;
-    }
-
-    case ExpressionKind::CompoundMemberAccessExpression: {
-      const auto& simple_member_access =
-          cast<CompoundMemberAccessExpression>(expression);
-      auto* simple_member_access_proto =
-          expression_proto.mutable_compound_member_access();
-      *simple_member_access_proto->mutable_object() =
-          ExpressionToProto(simple_member_access.object());
-      *simple_member_access_proto->mutable_path() =
-          ExpressionToProto(simple_member_access.path());
-      break;
-    }
-
-    case ExpressionKind::IndexExpression: {
-      const auto& index = cast<IndexExpression>(expression);
-      auto* index_proto = expression_proto.mutable_index();
-      *index_proto->mutable_object() = ExpressionToProto(index.object());
-      *index_proto->mutable_offset() = ExpressionToProto(index.offset());
-      break;
-    }
-
-    case ExpressionKind::OperatorExpression: {
-      const auto& operator_expr = cast<OperatorExpression>(expression);
-      auto* operator_proto = expression_proto.mutable_operator_();
-      operator_proto->set_op(OperatorToProtoEnum(operator_expr.op()));
-      for (Nonnull<const Expression*> arg : operator_expr.arguments()) {
-        *operator_proto->add_arguments() = ExpressionToProto(*arg);
-      }
-      break;
-    }
-
-    case ExpressionKind::TupleLiteral:
-      *expression_proto.mutable_tuple_literal() =
-          TupleLiteralExpressionToProto(cast<TupleLiteral>(expression));
-      break;
-
-    case ExpressionKind::StructLiteral: {
-      const auto& struct_literal = cast<StructLiteral>(expression);
-      auto* struct_literal_proto = expression_proto.mutable_struct_literal();
-      for (const FieldInitializer& field : struct_literal.fields()) {
-        *struct_literal_proto->add_fields() = FieldInitializerToProto(field);
-      }
-      break;
-    }
-
-    case ExpressionKind::StructTypeLiteral: {
-      const auto& struct_type_literal = cast<StructTypeLiteral>(expression);
-      auto* struct_type_literal_proto =
-          expression_proto.mutable_struct_type_literal();
-      for (const FieldInitializer& field : struct_type_literal.fields()) {
-        *struct_type_literal_proto->add_fields() =
-            FieldInitializerToProto(field);
-      }
-      break;
-    }
-
-    case ExpressionKind::IdentifierExpression: {
-      const auto& identifier = cast<IdentifierExpression>(expression);
-      auto* identifier_proto = expression_proto.mutable_identifier();
-      identifier_proto->set_name(identifier.name());
-      break;
-    }
-
-    case ExpressionKind::WhereExpression: {
-      const auto& where = cast<WhereExpression>(expression);
-      auto* where_proto = expression_proto.mutable_where();
-      *where_proto->mutable_base() =
-          ExpressionToProto(where.self_binding().type());
-      for (const WhereClause* where : where.clauses()) {
-        Fuzzing::WhereClause clause_proto;
-        switch (where->kind()) {
-          case WhereClauseKind::ImplsWhereClause: {
-            auto* impls_proto = clause_proto.mutable_impls();
-            *impls_proto->mutable_type() =
-                ExpressionToProto(cast<ImplsWhereClause>(where)->type());
-            *impls_proto->mutable_constraint() =
-                ExpressionToProto(cast<ImplsWhereClause>(where)->constraint());
-            break;
-          }
-          case WhereClauseKind::EqualsWhereClause: {
-            auto* equals_proto = clause_proto.mutable_equals();
-            *equals_proto->mutable_lhs() =
-                ExpressionToProto(cast<EqualsWhereClause>(where)->lhs());
-            *equals_proto->mutable_rhs() =
-                ExpressionToProto(cast<EqualsWhereClause>(where)->rhs());
-            break;
-          }
-          case WhereClauseKind::RewriteWhereClause: {
-            auto* rewrite = clause_proto.mutable_rewrite();
-            rewrite->set_member_name(
-                std::string(cast<RewriteWhereClause>(where)->member_name()));
-            *rewrite->mutable_replacement() = ExpressionToProto(
-                cast<RewriteWhereClause>(where)->replacement());
-            break;
-          }
-        }
-        *where_proto->add_clauses() = clause_proto;
-      }
-      break;
-    }
-
-    case ExpressionKind::DotSelfExpression: {
-      auto* designator_proto = expression_proto.mutable_designator();
-      designator_proto->set_name("Self");
-      break;
-    }
-
-    case ExpressionKind::IntrinsicExpression: {
-      const auto& intrinsic = cast<IntrinsicExpression>(expression);
-      auto* call_proto = expression_proto.mutable_call();
-      call_proto->mutable_function()->mutable_identifier()->set_name(
-          std::string(intrinsic.name()));
-      *call_proto->mutable_argument() = ExpressionToProto(intrinsic.args());
-      break;
-    }
-
-    case ExpressionKind::IfExpression: {
-      const auto& if_expression = cast<IfExpression>(expression);
-      auto* if_proto = expression_proto.mutable_if_expression();
-      *if_proto->mutable_condition() =
-          ExpressionToProto(if_expression.condition());
-      *if_proto->mutable_then_expression() =
-          ExpressionToProto(if_expression.then_expression());
-      *if_proto->mutable_else_expression() =
-          ExpressionToProto(if_expression.else_expression());
-      break;
-    }
-
-    case ExpressionKind::BoolTypeLiteral:
-      expression_proto.mutable_bool_type_literal();
-      break;
-
-    case ExpressionKind::BoolLiteral:
-      expression_proto.mutable_bool_literal()->set_value(
-          cast<BoolLiteral>(expression).value());
-      break;
-
-    case ExpressionKind::IntTypeLiteral:
-      expression_proto.mutable_int_type_literal();
-      break;
-
-    case ExpressionKind::IntLiteral:
-      expression_proto.mutable_int_literal()->set_value(
-          cast<IntLiteral>(expression).value());
-      break;
-
-    case ExpressionKind::StringLiteral:
-      expression_proto.mutable_string_literal()->set_value(
-          cast<StringLiteral>(expression).value());
-      break;
-
-    case ExpressionKind::StringTypeLiteral:
-      expression_proto.mutable_string_type_literal();
-      break;
-
-    case ExpressionKind::TypeTypeLiteral:
-      expression_proto.mutable_type_type_literal();
-      break;
-
-    case ExpressionKind::UnimplementedExpression:
-      expression_proto.mutable_unimplemented_expression();
-      break;
-
-    case ExpressionKind::ArrayTypeLiteral: {
-      const auto& array_literal = cast<ArrayTypeLiteral>(expression);
-      Fuzzing::ArrayTypeLiteral* array_literal_proto =
-          expression_proto.mutable_array_type_literal();
-      *array_literal_proto->mutable_element_type() =
-          ExpressionToProto(array_literal.element_type_expression());
-      if (array_literal.has_size_expression()) {
-        *array_literal_proto->mutable_size() =
-            ExpressionToProto(array_literal.size_expression());
-      }
-      break;
-    }
-  }
-  return expression_proto;
-}
-
-static auto BindingPatternToProto(const BindingPattern& pattern)
-    -> Fuzzing::BindingPattern {
-  Fuzzing::BindingPattern pattern_proto;
-  pattern_proto.set_name(pattern.name());
-  *pattern_proto.mutable_type() = PatternToProto(pattern.type());
-  return pattern_proto;
-}
-
-static auto GenericBindingToProto(const GenericBinding& binding)
-    -> Fuzzing::GenericBinding {
-  Fuzzing::GenericBinding binding_proto;
-  binding_proto.set_name(binding.name());
-  *binding_proto.mutable_type() = ExpressionToProto(binding.type());
-  switch (binding.binding_kind()) {
-    case GenericBinding::BindingKind::Checked:
-      binding_proto.set_kind(Fuzzing::GenericBinding::Checked);
-      break;
-    case GenericBinding::BindingKind::Template:
-      binding_proto.set_kind(Fuzzing::GenericBinding::Template);
-      break;
-  }
-  return binding_proto;
-}
-
-static auto TuplePatternToProto(const TuplePattern& tuple_pattern)
-    -> Fuzzing::TuplePattern {
-  Fuzzing::TuplePattern tuple_pattern_proto;
-  for (Nonnull<const Pattern*> field : tuple_pattern.fields()) {
-    *tuple_pattern_proto.add_fields() = PatternToProto(*field);
-  }
-  return tuple_pattern_proto;
-}
-
-static auto PatternToProto(const Pattern& pattern) -> Fuzzing::Pattern {
-  Fuzzing::Pattern pattern_proto;
-  switch (pattern.kind()) {
-    case PatternKind::GenericBinding: {
-      const auto& binding = cast<GenericBinding>(pattern);
-      *pattern_proto.mutable_generic_binding() = GenericBindingToProto(binding);
-      break;
-    }
-    case PatternKind::BindingPattern: {
-      const auto& binding = cast<BindingPattern>(pattern);
-      *pattern_proto.mutable_binding_pattern() = BindingPatternToProto(binding);
-      break;
-    }
-    case PatternKind::TuplePattern:
-      *pattern_proto.mutable_tuple_pattern() =
-          TuplePatternToProto(cast<TuplePattern>(pattern));
-      break;
-
-    case PatternKind::AlternativePattern: {
-      const auto& alternative = cast<AlternativePattern>(pattern);
-      auto* alternative_proto = pattern_proto.mutable_alternative_pattern();
-      alternative_proto->set_alternative_name(alternative.alternative_name());
-      *alternative_proto->mutable_choice_type() =
-          ExpressionToProto(alternative.choice_type());
-      *alternative_proto->mutable_arguments() =
-          TuplePatternToProto(alternative.arguments());
-      break;
-    }
-
-    case PatternKind::ExpressionPattern:
-      *pattern_proto.mutable_expression_pattern()->mutable_expression() =
-          ExpressionToProto(cast<ExpressionPattern>(pattern).expression());
-      break;
-
-    case PatternKind::AutoPattern:
-      pattern_proto.mutable_auto_pattern();
-      break;
-
-    case PatternKind::VarPattern:
-      *pattern_proto.mutable_var_pattern()->mutable_pattern() =
-          PatternToProto(cast<VarPattern>(pattern).pattern());
-      break;
-    case PatternKind::AddrPattern:
-      *pattern_proto.mutable_addr_pattern()->mutable_binding_pattern() =
-          BindingPatternToProto(cast<AddrPattern>(pattern).binding());
-      break;
-  }
-  return pattern_proto;
-}
-
-static auto BlockStatementToProto(const Block& block)
-    -> Fuzzing::BlockStatement {
-  Fuzzing::BlockStatement block_proto;
-  for (Nonnull<const Statement*> statement : block.statements()) {
-    *block_proto.add_statements() = StatementToProto(*statement);
-  }
-  return block_proto;
-}
-
-static auto StatementToProto(const Statement& statement) -> Fuzzing::Statement {
-  Fuzzing::Statement statement_proto;
-  switch (statement.kind()) {
-    case StatementKind::ExpressionStatement:
-      *statement_proto.mutable_expression_statement()->mutable_expression() =
-          ExpressionToProto(cast<ExpressionStatement>(statement).expression());
-      break;
-
-    case StatementKind::Assign: {
-      const auto& assign = cast<Assign>(statement);
-      auto* assign_proto = statement_proto.mutable_assign();
-      *assign_proto->mutable_lhs() = ExpressionToProto(assign.lhs());
-      *assign_proto->mutable_rhs() = ExpressionToProto(assign.rhs());
-      assign_proto->set_op(AssignOperatorToProtoEnum(assign.op()));
-      break;
-    }
-
-    case StatementKind::IncrementDecrement: {
-      const auto& inc_dec = cast<IncrementDecrement>(statement);
-      auto* inc_dec_proto = statement_proto.mutable_inc_dec();
-      *inc_dec_proto->mutable_operand() = ExpressionToProto(inc_dec.argument());
-      inc_dec_proto->set_is_increment(inc_dec.is_increment());
-      break;
-    }
-
-    case StatementKind::VariableDefinition: {
-      const auto& def = cast<VariableDefinition>(statement);
-      auto* def_proto = statement_proto.mutable_variable_definition();
-      *def_proto->mutable_pattern() = PatternToProto(def.pattern());
-      if (def.has_init()) {
-        *def_proto->mutable_init() = ExpressionToProto(def.init());
-      }
-      def_proto->set_is_returned(def.is_returned());
-      break;
-    }
-
-    case StatementKind::If: {
-      const auto& if_stmt = cast<If>(statement);
-      auto* if_proto = statement_proto.mutable_if_statement();
-      *if_proto->mutable_condition() = ExpressionToProto(if_stmt.condition());
-      *if_proto->mutable_then_block() =
-          BlockStatementToProto(if_stmt.then_block());
-      if (if_stmt.else_block().has_value()) {
-        *if_proto->mutable_else_block() =
-            BlockStatementToProto(**if_stmt.else_block());
-      }
-      break;
-    }
-
-    case StatementKind::ReturnVar: {
-      statement_proto.mutable_return_var_statement();
-      break;
-    }
-
-    case StatementKind::ReturnExpression: {
-      const auto& ret = cast<ReturnExpression>(statement);
-      auto* ret_proto = statement_proto.mutable_return_expression_statement();
-      if (!ret.is_omitted_expression()) {
-        *ret_proto->mutable_expression() = ExpressionToProto(ret.expression());
-      } else {
-        ret_proto->set_is_omitted_expression(true);
-      }
-      break;
-    }
-
-    case StatementKind::Block:
-      *statement_proto.mutable_block() =
-          BlockStatementToProto(cast<Block>(statement));
-      break;
-
-    case StatementKind::While: {
-      const auto& while_stmt = cast<While>(statement);
-      auto* while_proto = statement_proto.mutable_while_statement();
-      *while_proto->mutable_condition() =
-          ExpressionToProto(while_stmt.condition());
-      *while_proto->mutable_body() = BlockStatementToProto(while_stmt.body());
-      break;
-    }
-
-    case StatementKind::Match: {
-      const auto& match = cast<Match>(statement);
-      auto* match_proto = statement_proto.mutable_match();
-      *match_proto->mutable_expression() =
-          ExpressionToProto(match.expression());
-      for (const Match::Clause& clause : match.clauses()) {
-        auto* clause_proto = match_proto->add_clauses();
-        // TODO: Working out whether we have a default clause after the fact
-        // like this is fragile.
-        bool is_default_clause = false;
-        if (const auto* binding = dyn_cast<BindingPattern>(&clause.pattern())) {
-          if (binding->name() == AnonymousName &&
-              isa<AutoPattern>(binding->type()) &&
-              binding->source_loc() == binding->type().source_loc()) {
-            is_default_clause = true;
-          }
-        }
-        if (is_default_clause) {
-          clause_proto->set_is_default(true);
-        } else {
-          *clause_proto->mutable_pattern() = PatternToProto(clause.pattern());
-        }
-        *clause_proto->mutable_statement() =
-            StatementToProto(clause.statement());
-      }
-      break;
-    }
-
-    case StatementKind::Break:
-      // Initializes with the default value; there's nothing to set.
-      statement_proto.mutable_break_statement();
-      break;
-
-    case StatementKind::Continue:
-      // Initializes with the default value; there's nothing to set.
-      statement_proto.mutable_continue_statement();
-      break;
-
-    case StatementKind::For: {
-      const auto& for_stmt = cast<For>(statement);
-      auto* for_proto = statement_proto.mutable_for_statement();
-      *for_proto->mutable_var_decl() =
-          BindingPatternToProto(for_stmt.variable_declaration());
-      *for_proto->mutable_target() = ExpressionToProto(for_stmt.loop_target());
-      *for_proto->mutable_body() = BlockStatementToProto(for_stmt.body());
-      break;
-    }
-  }
-  return statement_proto;
-}
-
-static auto ReturnTermToProto(const ReturnTerm& return_term)
-    -> Fuzzing::ReturnTerm {
-  Fuzzing::ReturnTerm return_term_proto;
-  if (return_term.is_omitted()) {
-    return_term_proto.set_kind(Fuzzing::ReturnTerm::Omitted);
-  } else if (return_term.is_auto()) {
-    return_term_proto.set_kind(Fuzzing::ReturnTerm::Auto);
-  } else {
-    return_term_proto.set_kind(Fuzzing::ReturnTerm::Expression);
-    *return_term_proto.mutable_type() =
-        ExpressionToProto(**return_term.type_expression());
-  }
-  return return_term_proto;
-}
-
-static auto DeclaredNameToProto(const DeclaredName& name)
-    -> Fuzzing::DeclaredName {
-  Fuzzing::DeclaredName name_proto;
-  name_proto.set_name(std::string(name.inner_name()));
-  for (const auto& [loc, qual] : name.qualifiers()) {
-    name_proto.add_qualifiers(qual);
-  }
-  return name_proto;
-}
-
-static auto DeclarationToProto(const Declaration& declaration)
-    -> Fuzzing::Declaration {
-  Fuzzing::Declaration declaration_proto;
-  switch (declaration.kind()) {
-    case DeclarationKind::NamespaceDeclaration: {
-      const auto& namespace_decl = cast<NamespaceDeclaration>(declaration);
-      auto* namespace_proto = declaration_proto.mutable_namespace_();
-      *namespace_proto->mutable_name() =
-          DeclaredNameToProto(namespace_decl.name());
-      break;
-    }
-    case DeclarationKind::DestructorDeclaration: {
-      const auto& function = cast<DestructorDeclaration>(declaration);
-      auto* function_proto = declaration_proto.mutable_destructor();
-      if (function.is_method()) {
-        switch (function.self_pattern().kind()) {
-          case PatternKind::AddrPattern:
-            *function_proto->mutable_self_pattern() =
-                PatternToProto(cast<AddrPattern>(function.self_pattern()));
-            break;
-          case PatternKind::BindingPattern:
-            *function_proto->mutable_self_pattern() =
-                PatternToProto(cast<BindingPattern>(function.self_pattern()));
-            break;
-          default:
-            // Parser shouldn't allow self_pattern to be anything other than
-            // AddrPattern or BindingPattern
-            CARBON_FATAL(
-                "self_pattern in method declaration can be either AddrPattern "
-                "or BindingPattern. Actual pattern: {0}",
-                function.self_pattern());
-            break;
-        }
-      }
-      if (function.body().has_value()) {
-        *function_proto->mutable_body() =
-            BlockStatementToProto(**function.body());
-      }
-      break;
-    }
-
-    case DeclarationKind::FunctionDeclaration: {
-      const auto& function = cast<FunctionDeclaration>(declaration);
-      auto* function_proto = declaration_proto.mutable_function();
-      *function_proto->mutable_name() = DeclaredNameToProto(function.name());
-      for (Nonnull<const GenericBinding*> binding :
-           function.deduced_parameters()) {
-        *function_proto->add_deduced_parameters() =
-            GenericBindingToProto(*binding);
-      }
-      if (function.is_method()) {
-        switch (function.self_pattern().kind()) {
-          case PatternKind::AddrPattern:
-            *function_proto->mutable_self_pattern() =
-                PatternToProto(cast<AddrPattern>(function.self_pattern()));
-            break;
-          case PatternKind::BindingPattern:
-            *function_proto->mutable_self_pattern() =
-                PatternToProto(cast<BindingPattern>(function.self_pattern()));
-            break;
-          default:
-            // Parser shouldn't allow self_pattern to be anything other than
-            // AddrPattern or BindingPattern
-            CARBON_FATAL(
-                "self_pattern in method declaration can be either AddrPattern "
-                "or BindingPattern. Actual pattern: {0}",
-                function.self_pattern());
-            break;
-        }
-      }
-      *function_proto->mutable_param_pattern() =
-          TuplePatternToProto(function.param_pattern());
-      *function_proto->mutable_return_term() =
-          ReturnTermToProto(function.return_term());
-      if (function.body().has_value()) {
-        *function_proto->mutable_body() =
-            BlockStatementToProto(**function.body());
-      }
-      break;
-    }
-
-    case DeclarationKind::ClassDeclaration: {
-      const auto& class_decl = cast<ClassDeclaration>(declaration);
-      auto* class_proto = declaration_proto.mutable_class_declaration();
-      *class_proto->mutable_name() = DeclaredNameToProto(class_decl.name());
-      if (class_decl.type_params().has_value()) {
-        *class_proto->mutable_type_params() =
-            TuplePatternToProto(**class_decl.type_params());
-      }
-      for (Nonnull<const Declaration*> member : class_decl.members()) {
-        *class_proto->add_members() = DeclarationToProto(*member);
-      }
-      break;
-    }
-
-    case DeclarationKind::MixinDeclaration: {
-      const auto& mixin = cast<MixinDeclaration>(declaration);
-      auto* mixin_proto = declaration_proto.mutable_mixin();
-      *mixin_proto->mutable_name() = DeclaredNameToProto(mixin.name());
-      for (const auto& member : mixin.members()) {
-        *mixin_proto->add_members() = DeclarationToProto(*member);
-      }
-      // Type params not implemented yet
-      // if (mixin.params().has_value()) {
-      //  *mixin_proto->mutable_params() =
-      //      TuplePatternToProto(**mixin.params());
-      //}
-      *mixin_proto->mutable_self() = GenericBindingToProto(*mixin.self());
-      break;
-    }
-
-    case DeclarationKind::MixDeclaration: {
-      const auto& mix = cast<MixDeclaration>(declaration);
-      auto* mix_proto = declaration_proto.mutable_mix();
-      *mix_proto->mutable_mixin() = ExpressionToProto(mix.mixin());
-      break;
-    }
-
-    case DeclarationKind::ChoiceDeclaration: {
-      const auto& choice = cast<ChoiceDeclaration>(declaration);
-      auto* choice_proto = declaration_proto.mutable_choice();
-      *choice_proto->mutable_name() = DeclaredNameToProto(choice.name());
-      for (Nonnull<const AlternativeSignature*> alternative :
-           choice.alternatives()) {
-        auto* alternative_proto = choice_proto->add_alternatives();
-        alternative_proto->set_name(alternative->name());
-        if (auto params = alternative->parameters()) {
-          *alternative_proto->mutable_signature() =
-              TupleLiteralExpressionToProto(**params);
-        }
-      }
-      break;
-    }
-
-    case DeclarationKind::VariableDeclaration: {
-      const auto& var = cast<VariableDeclaration>(declaration);
-      auto* var_proto = declaration_proto.mutable_variable();
-      *var_proto->mutable_binding() = BindingPatternToProto(var.binding());
-      if (var.has_initializer()) {
-        *var_proto->mutable_initializer() =
-            ExpressionToProto(var.initializer());
-      }
-      break;
-    }
-
-    case DeclarationKind::InterfaceExtendDeclaration: {
-      const auto& extend = cast<InterfaceExtendDeclaration>(declaration);
-      auto* extend_proto = declaration_proto.mutable_interface_extend();
-      *extend_proto->mutable_base() = ExpressionToProto(*extend.base());
-      break;
-    }
-
-    case DeclarationKind::InterfaceRequireDeclaration: {
-      const auto& require = cast<InterfaceRequireDeclaration>(declaration);
-      auto* require_proto = declaration_proto.mutable_interface_require();
-      *require_proto->mutable_impl_type() =
-          ExpressionToProto(*require.impl_type());
-      *require_proto->mutable_constraint() =
-          ExpressionToProto(*require.constraint());
-      break;
-    }
-
-    case DeclarationKind::AssociatedConstantDeclaration: {
-      const auto& assoc = cast<AssociatedConstantDeclaration>(declaration);
-      auto* let_proto = declaration_proto.mutable_let();
-      *let_proto->mutable_pattern() = PatternToProto(assoc.binding());
-      break;
-    }
-
-    case DeclarationKind::InterfaceDeclaration: {
-      const auto& interface = cast<InterfaceDeclaration>(declaration);
-      auto* interface_proto = declaration_proto.mutable_interface();
-      *interface_proto->mutable_name() = DeclaredNameToProto(interface.name());
-      for (const auto& member : interface.members()) {
-        *interface_proto->add_members() = DeclarationToProto(*member);
-      }
-      break;
-    }
-
-    case DeclarationKind::ConstraintDeclaration: {
-      const auto& constraint = cast<ConstraintDeclaration>(declaration);
-      auto* constraint_proto = declaration_proto.mutable_constraint();
-      *constraint_proto->mutable_name() =
-          DeclaredNameToProto(constraint.name());
-      for (const auto& member : constraint.members()) {
-        *constraint_proto->add_members() = DeclarationToProto(*member);
-      }
-      break;
-    }
-
-    case DeclarationKind::ImplDeclaration: {
-      const auto& impl = cast<ImplDeclaration>(declaration);
-      auto* impl_proto = declaration_proto.mutable_impl();
-      switch (impl.kind()) {
-        case ImplKind::InternalImpl:
-          impl_proto->set_kind(Fuzzing::ImplDeclaration::InternalImpl);
-          break;
-        case ImplKind::ExternalImpl:
-          impl_proto->set_kind(Fuzzing::ImplDeclaration::ExternalImpl);
-          break;
-      }
-      for (Nonnull<const GenericBinding*> binding : impl.deduced_parameters()) {
-        *impl_proto->add_deduced_parameters() = GenericBindingToProto(*binding);
-      }
-      *impl_proto->mutable_impl_type() = ExpressionToProto(*impl.impl_type());
-      *impl_proto->mutable_interface() = ExpressionToProto(impl.interface());
-      for (const auto& member : impl.members()) {
-        *impl_proto->add_members() = DeclarationToProto(*member);
-      }
-      break;
-    }
-
-    case DeclarationKind::MatchFirstDeclaration: {
-      const auto& match_first = cast<MatchFirstDeclaration>(declaration);
-      auto* match_first_proto = declaration_proto.mutable_match_first();
-      for (const auto* impl : match_first.impl_declarations()) {
-        *match_first_proto->add_impl_declarations() = DeclarationToProto(*impl);
-      }
-      break;
-    }
-
-    case DeclarationKind::SelfDeclaration: {
-      CARBON_FATAL("Unreachable SelfDeclaration in DeclarationToProto().");
-    }
-
-    case DeclarationKind::AliasDeclaration: {
-      const auto& alias = cast<AliasDeclaration>(declaration);
-      auto* alias_proto = declaration_proto.mutable_alias();
-      *alias_proto->mutable_name() = DeclaredNameToProto(alias.name());
-      *alias_proto->mutable_target() = ExpressionToProto(alias.target());
-      break;
-    }
-
-    case DeclarationKind::ExtendBaseDeclaration: {
-      const auto& extend_base = cast<ExtendBaseDeclaration>(declaration);
-      auto* extend_base_proto = declaration_proto.mutable_extend_base();
-      *extend_base_proto->mutable_base_class() =
-          ExpressionToProto(*extend_base.base_class());
-      break;
-    }
-  }
-  return declaration_proto;
-}
-
-auto AstToProto(const AST& ast) -> Fuzzing::Carbon {
-  Fuzzing::Carbon carbon;
-  auto* unit = carbon.mutable_compilation_unit();
-  *unit->mutable_package_statement() = LibraryNameToProto(ast.package);
-  unit->set_is_api(ast.is_api);
-  for (const Declaration* declaration : ast.declarations) {
-    *unit->add_declarations() = DeclarationToProto(*declaration);
-  }
-  return carbon;
-}
-
-}  // namespace Carbon::Testing

explorer/fuzzing/ast_to_proto.h

@@ -1,18 +0,0 @@
-// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-// Exceptions. See /LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#ifndef CARBON_EXPLORER_FUZZING_AST_TO_PROTO_H_
-#define CARBON_EXPLORER_FUZZING_AST_TO_PROTO_H_
-
-#include "explorer/ast/ast.h"
-#include "testing/fuzzing/carbon.pb.h"
-
-namespace Carbon::Testing {
-
-// Builds a protobuf representation of `ast`.
-auto AstToProto(const AST& ast) -> Fuzzing::Carbon;
-
-}  // namespace Carbon::Testing
-
-#endif  // CARBON_EXPLORER_FUZZING_AST_TO_PROTO_H_

explorer/fuzzing/ast_to_proto_main.cpp

@@ -1,61 +0,0 @@
-// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-// Exceptions. See /LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-// To convert a Carbon file to a text proto:
-// `ast_to_proto <file.carbon>`
-
-#include <google/protobuf/text_format.h>
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-
-#include "common/bazel_working_dir.h"
-#include "common/error.h"
-#include "explorer/ast/ast.h"
-#include "explorer/base/arena.h"
-#include "explorer/fuzzing/ast_to_proto.h"
-#include "explorer/syntax/parse.h"
-#include "testing/fuzzing/carbon.pb.h"
-
-namespace Carbon::Testing {
-
-static auto Main(int argc, char** argv) -> ErrorOr<Success> {
-  SetWorkingDirForBazel();
-
-  if (argc != 2) {
-    return Error("Syntax: ast_to_proto <file.carbon>");
-  }
-  if (!std::filesystem::is_regular_file(argv[1])) {
-    return Error("Argument must be a file.");
-  }
-
-  Arena arena;
-  const ErrorOr<AST> ast =
-      Parse(*llvm::vfs::getRealFileSystem(), &arena, argv[1], FileKind::Main,
-            /*parser_debug=*/false);
-  if (!ast.ok()) {
-    return ErrorBuilder() << "Parsing failed: " << ast.error().message();
-  }
-  Fuzzing::Carbon carbon_proto = AstToProto(*ast);
-
-  std::string proto_string;
-  google::protobuf::TextFormat::Printer p;
-  if (!p.PrintToString(carbon_proto, &proto_string)) {
-    return Error("Failed to convert to text proto");
-  }
-  std::cout << proto_string;
-  return Success();
-}
-
-}  // namespace Carbon::Testing
-
-auto main(int argc, char** argv) -> int {
-  auto err = Carbon::Testing::Main(argc, argv);
-  if (!err.ok()) {
-    std::cerr << err.error().message() << "\n";
-    return EXIT_FAILURE;
-  }
-  return EXIT_SUCCESS;
-}

explorer/fuzzing/ast_to_proto_test.cpp

@@ -1,208 +0,0 @@
-// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-// Exceptions. See /LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include "explorer/fuzzing/ast_to_proto.h"
-
-#include <gmock/gmock.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/util/message_differencer.h>
-#include <gtest/gtest.h>
-
-#include <filesystem>
-#include <numeric>
-#include <set>
-#include <variant>
-
-#include "explorer/syntax/parse.h"
-#include "testing/base/test_raw_ostream.h"
-#include "testing/fuzzing/proto_to_carbon.h"
-
-namespace Carbon::Testing {
-namespace {
-
-using ::google::protobuf::Descriptor;
-using ::google::protobuf::FieldDescriptor;
-using ::google::protobuf::Message;
-using ::google::protobuf::Reflection;
-
-static std::vector<llvm::StringRef>* carbon_files = nullptr;
-
-// Returns a string representation of `ast`.
-auto AstToString(const AST& ast) -> std::string {
-  TestRawOstream out;
-  out << "package " << ast.package.package << (ast.is_api ? "api" : "impl")
-      << ";\n";
-  for (auto* declaration : ast.declarations) {
-    out << *declaration << "\n";
-  }
-  return out.TakeStr();
-}
-
-// Concatenates message and field names.
-auto FieldName(const Descriptor& descriptor, const FieldDescriptor& field)
-    -> std::string {
-  return descriptor.full_name() + "." + field.name();
-}
-
-// Traverses the proto to find all unique messages and fields.
-auto CollectAllFields(const Descriptor& descriptor,
-                      std::set<std::string>& all_messages,
-                      std::set<std::string>& all_fields) -> void {
-  all_messages.insert(descriptor.full_name());
-  for (int i = 0; i < descriptor.field_count(); ++i) {
-    const FieldDescriptor* field = descriptor.field(i);
-    all_fields.insert(FieldName(descriptor, *field));
-    if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
-        all_messages.find(field->message_type()->full_name()) ==
-            all_messages.end()) {
-      CollectAllFields(*field->message_type(), all_messages, all_fields);
-    }
-  }
-}
-
-// Traverses an instance of the proto to find all used fields.
-auto CollectUsedFields(const Message& message,
-                       std::set<std::string>& used_fields) -> void {
-  const Descriptor* descriptor = message.GetDescriptor();
-  const Reflection* reflection = message.GetReflection();
-  for (int i = 0; i < descriptor->field_count(); ++i) {
-    const FieldDescriptor* field = descriptor->field(i);
-    if (!field->is_repeated()) {
-      if (reflection->HasField(message, field)) {
-        used_fields.insert(FieldName(*descriptor, *field));
-      }
-    } else {
-      if (reflection->FieldSize(message, field) > 0) {
-        used_fields.insert(FieldName(*descriptor, *field));
-      }
-    }
-    if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
-      if (!field->is_repeated()) {
-        if (reflection->HasField(message, field)) {
-          CollectUsedFields(reflection->GetMessage(message, field),
-                            used_fields);
-        }
-      } else {
-        for (int i = 0; i < reflection->FieldSize(message, field); ++i) {
-          CollectUsedFields(reflection->GetRepeatedMessage(message, field, i),
-                            used_fields);
-        }
-      }
-    }
-  }
-}
-
-// A 'smoke' test to check that each field present in `carbon.proto` is set at
-// least once after converting all Carbon test sources to proto representation.
-TEST(AstToProtoTest, SetsAllProtoFields) {
-  Fuzzing::Carbon merged_proto;
-  for (const llvm::StringRef f : *carbon_files) {
-    Arena arena;
-    const ErrorOr<AST> ast = Parse(*llvm::vfs::getRealFileSystem(), &arena, f,
-                                   FileKind::Main, /*parser_debug=*/false);
-    if (ast.ok()) {
-      merged_proto.MergeFrom(AstToProto(*ast));
-    }
-  }
-
-  std::set<std::string> all_messages;
-  std::set<std::string> all_fields;
-  CollectAllFields(*Fuzzing::Carbon::GetDescriptor(), all_messages, all_fields);
-
-  std::set<std::string> used_fields;
-  CollectUsedFields(merged_proto, used_fields);
-
-  std::set<std::string> unused_fields;
-  std::set_difference(all_fields.begin(), all_fields.end(), used_fields.begin(),
-                      used_fields.end(),
-                      std::inserter(unused_fields, unused_fields.begin()));
-  EXPECT_EQ(unused_fields.size(), 0)
-      << "Unused fields"
-      << std::accumulate(unused_fields.begin(), unused_fields.end(),
-                         std::string(),
-                         [](const std::string& a, const std::string& b) {
-                           return a + '\n' + b;
-                         });
-}
-
-// Ensures that `carbon.proto` is able to represent ASTs correctly without
-// information loss by doing round-trip testing of files:
-//
-// 1) Converts each parseable Carbon file to a proto representation.
-// 2) Converts back to Carbon source.
-// 3) Parses the source into a second instance of an AST.
-// 4) Compares the second AST with the original.
-TEST(AstToProtoTest, Roundtrip) {
-  int parsed_ok_count = 0;
-  for (const llvm::StringRef f : *carbon_files) {
-    Arena arena;
-    const ErrorOr<AST> ast = Parse(*llvm::vfs::getRealFileSystem(), &arena, f,
-                                   FileKind::Main, /*parser_debug=*/false);
-    if (ast.ok()) {
-      ++parsed_ok_count;
-      const std::string source_from_proto =
-          ProtoToCarbon(AstToProto(*ast), /*maybe_add_main=*/false);
-      SCOPED_TRACE(testing::Message()
-                   << "Carbon file: " << f << ", source from proto:\n"
-                   << source_from_proto);
-      const ErrorOr<AST> ast_from_proto = ParseFromString(
-          &arena, f, FileKind::Main, source_from_proto, /*parser_debug=*/false);
-
-      if (ast_from_proto.ok()) {
-        EXPECT_EQ(AstToString(*ast), AstToString(*ast_from_proto));
-      } else {
-        ADD_FAILURE() << "Parse error " << ast_from_proto.error().message();
-      }
-    }
-  }
-  // Makes sure files were actually processed.
-  EXPECT_GT(parsed_ok_count, 0);
-}
-
-auto CloneAST(Arena& arena, const AST& ast) -> AST {
-  CloneContext context(&arena);
-  return {
-      .package = ast.package,
-      .is_api = ast.is_api,
-      .imports = ast.imports,
-      .declarations = context.Clone(ast.declarations),
-      .main_call = context.Clone(ast.main_call),
-      .num_prelude_declarations = ast.num_prelude_declarations,
-  };
-}
-
-// Verifies that an AST and its clone produce identical protos.
-TEST(AstToProtoTest, SameProtoAfterClone) {
-  int parsed_ok_count = 0;
-  for (const llvm::StringRef f : *carbon_files) {
-    Arena arena;
-    const ErrorOr<AST> ast = Parse(*llvm::vfs::getRealFileSystem(), &arena, f,
-                                   FileKind::Main, /*parser_debug=*/false);
-    if (ast.ok()) {
-      ++parsed_ok_count;
-      const AST clone = CloneAST(arena, *ast);
-      const Fuzzing::Carbon orig_proto = AstToProto(*ast);
-      const Fuzzing::Carbon clone_proto = AstToProto(clone);
-      // TODO: Use EqualsProto once it's available.
-      EXPECT_TRUE(google::protobuf::util::MessageDifferencer::Equals(
-          orig_proto, clone_proto))
-          << "clone produced a different AST. original:\n"
-          << AstToString(*ast) << "clone:\n"
-          << AstToString(clone);
-    }
-  }
-  // Makes sure files were actually processed.
-  EXPECT_GT(parsed_ok_count, 0);
-}
-
-}  // namespace
-}  // namespace Carbon::Testing
-
-auto main(int argc, char** argv) -> int {
-  ::testing::InitGoogleTest(&argc, argv);
-  // gtest should remove flags, leaving just input files.
-  std::vector<llvm::StringRef> carbon_files(&argv[1], &argv[argc]);
-  Carbon::Testing::carbon_files = &carbon_files;
-  return RUN_ALL_TESTS();
-}

explorer/fuzzing/explorer_fuzzer.cpp

@@ -1,14 +0,0 @@
-// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
-// Exceptions. See /LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include <libfuzzer/libfuzzer_macro.h>
-
-#include "common/error.h"
-#include "explorer/fuzzing/fuzzer_util.h"
-#include "llvm/Support/raw_ostream.h"
-
-DEFINE_TEXT_PROTO_FUZZER(const Carbon::Fuzzing::Carbon& input) {
-  // Only verifying it doesn't crash.
-  (void)Carbon::Testing::ParseAndExecuteProto(input);
-}

explorer/fuzzing/fuzzer_corpus/0058bf96eefe20ae6eaceee383c12d36907710f2

@@ -1,92 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "t"
-                type {
-                  auto_pattern {
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 5
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          match {
-            expression {
-              identifier {
-                name: "t"
-              }
-            }
-            clauses {
-              pattern {
-                generic_binding {
-                  name: "T"
-                  type {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              is_default: true
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/015080d35638d6c7a6dce55192171f043955fe3e

@@ -1,161 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        function {
-          name {
-            name: "Origin"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Point"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "f"
-                type {
-                  expression_pattern {
-                    expression {
-                      function_type {
-                        return_type {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        parameter {
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              simple_member_access {
-                field: "Origin"
-                object {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "x"
-                object {
-                  call {
-                    function {
-                      identifier {
-                        name: "f"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/03bc316209e9f44df5533e0b4c72641729b3f4f9

@@ -1,266 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: InternalImpl
-      impl_type {
-        identifier {
-          name: "A"
-        }
-      }
-      interface {
-        call {
-          function {
-            identifier {
-              name: "ImplicitAs"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Convert"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          match {
-            expression {
-              tuple_literal {
-                fields {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                fields {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    expression_pattern {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "n"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "A"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "n"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "A"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                expression_pattern {
-                  expression {
-                    tuple_literal {
-                      fields {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                      fields {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/03ca8fb6a63c2623870c2f28d0f7a64ffbfd5802

@@ -1,182 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "lhs"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 8
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "rhs"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 3
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "Interface: {0}"
-                      }
-                    }
-                    fields {
-                      call {
-                        function {
-                          compound_member_access {
-                            object {
-                              identifier {
-                                name: "lhs"
-                              }
-                            }
-                            path {
-                              simple_member_access {
-                                field: "Op"
-                                object {
-                                  call {
-                                    function {
-                                      identifier {
-                                        name: "ModWith"
-                                      }
-                                    }
-                                    argument {
-                                      tuple_literal {
-                                        fields {
-                                          int_type_literal {
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              identifier {
-                                name: "rhs"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "Op: {0}"
-                      }
-                    }
-                    fields {
-                      operator {
-                        op: Mod
-                        arguments {
-                          identifier {
-                            name: "lhs"
-                          }
-                        }
-                        arguments {
-                          identifier {
-                            name: "rhs"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/041848ccba146125cb9038e818f54c3b495a6ad8

@@ -1,76 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          tuple_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              tuple_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0481d56f09c69f10476dc2498c39d6e7d4c24174

@@ -1,279 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        function {
-          name {
-            name: "Origin"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "zero"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        identifier {
-                          name: "zero"
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        identifier {
-                          name: "zero"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "GetX"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Point"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "T"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "x"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Origin"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "GetX"
-                    object {
-                      identifier {
-                        name: "p"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/049f14948dace26b462bbe7e8a8675fe701608cb

@@ -1,274 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    alias {
-      name {
-        name: "AB"
-      }
-      target {
-        struct_type_literal {
-          fields {
-            name: "a"
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-          fields {
-            name: "b"
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    alias {
-      name {
-        name: "BA"
-      }
-      target {
-        struct_type_literal {
-          fields {
-            name: "b"
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-          fields {
-            name: "a"
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "ab"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "AB"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "b"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-                fields {
-                  name: "a"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "ba"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "BA"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              identifier {
-                name: "ab"
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "ab.a: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "a"
-                        object {
-                          identifier {
-                            name: "ab"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "ab.b: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "b"
-                        object {
-                          identifier {
-                            name: "ab"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "ba.a: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "a"
-                        object {
-                          identifier {
-                            name: "ba"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "ba.b: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "b"
-                        object {
-                          identifier {
-                            name: "ba"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/04c215eb24bf843a80babc4e3dd313b95c4e571f

@@ -1,247 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        function {
-          name {
-            name: "Create"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            fields {
-              binding_pattern {
-                name: "y"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        identifier {
-                          name: "x"
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        identifier {
-                          name: "y"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Create"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "x"
-                object {
-                  identifier {
-                    name: "p"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0501aa4f45620235f062645d5ea731cb1927e39a

@@ -1,468 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "A"
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "TA"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "FA"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "TA"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    interface {
-      name {
-        name: "B"
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "TB"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "FB"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "TB"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "C"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            where {
-              base {
-                operator {
-                  op: BitwiseAnd
-                  arguments {
-                    identifier {
-                      name: "A"
-                    }
-                  }
-                  arguments {
-                    identifier {
-                      name: "B"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "TA"
-                  replacement {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "TB"
-                  replacement {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "FA"
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  variable_definition {
-                    pattern {
-                      binding_pattern {
-                        name: "v"
-                        type {
-                          expression_pattern {
-                            expression {
-                              compound_member_access {
-                                object {
-                                  identifier {
-                                    name: "Self"
-                                  }
-                                }
-                                path {
-                                  simple_member_access {
-                                    field: "TA"
-                                    object {
-                                      identifier {
-                                        name: "A"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    init {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                    is_returned: false
-                  }
-                }
-                statements {
-                  variable_definition {
-                    pattern {
-                      binding_pattern {
-                        name: "w"
-                        type {
-                          expression_pattern {
-                            expression {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    init {
-                      identifier {
-                        name: "v"
-                      }
-                    }
-                    is_returned: false
-                  }
-                }
-                statements {
-                  return_expression_statement {
-                    expression {
-                      identifier {
-                        name: "w"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "FB"
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  variable_definition {
-                    pattern {
-                      binding_pattern {
-                        name: "v"
-                        type {
-                          expression_pattern {
-                            expression {
-                              compound_member_access {
-                                object {
-                                  identifier {
-                                    name: "Self"
-                                  }
-                                }
-                                path {
-                                  simple_member_access {
-                                    field: "TB"
-                                    object {
-                                      identifier {
-                                        name: "B"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    init {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                    is_returned: false
-                  }
-                }
-                statements {
-                  variable_definition {
-                    pattern {
-                      binding_pattern {
-                        name: "w"
-                        type {
-                          expression_pattern {
-                            expression {
-                              compound_member_access {
-                                object {
-                                  identifier {
-                                    name: "Self"
-                                  }
-                                }
-                                path {
-                                  simple_member_access {
-                                    field: "TA"
-                                    object {
-                                      identifier {
-                                        name: "A"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    init {
-                      int_literal {
-                        value: 3
-                      }
-                    }
-                    is_returned: false
-                  }
-                }
-                statements {
-                  return_expression_statement {
-                    expression {
-                      operator {
-                        op: Add
-                        arguments {
-                          identifier {
-                            name: "v"
-                          }
-                        }
-                        arguments {
-                          identifier {
-                            name: "w"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        call {
-          function {
-            identifier {
-              name: "C"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      interface {
-        where {
-          base {
-            identifier {
-              name: "B"
-            }
-          }
-          clauses {
-            equals {
-              lhs {
-                designator {
-                  name: "TB"
-                }
-              }
-              rhs {
-                tuple_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "FB"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              tuple_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "FB"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "C"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0542a56192cecd529b82ed2081aa5459863f359e

@@ -1,95 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 5
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: As
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/05cc07bd9d1ef5b891c4f0df70a1463922009b5e

@@ -1,3473 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    choice {
-      name {
-        name: "AB"
-      }
-      alternatives {
-        name: "A"
-        signature {
-        }
-      }
-      alternatives {
-        name: "B"
-        signature {
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          identifier {
-            name: "AB"
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "A"
-                    object {
-                      identifier {
-                        name: "AB"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          match {
-            expression {
-              tuple_literal {
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                fields {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                expression_pattern {
-                  expression {
-                    tuple_literal {
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                expression_pattern {
-                  expression {
-                    tuple_literal {
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 2
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 3
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 4
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 5
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 6
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 7
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 8
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 9
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 10
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 11
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 12
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 13
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 14
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 15
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "A"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 16
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "AB"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "B"
-                              object {
-                                identifier {
-                                  name: "AB"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 17
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/05ec89686a7f7283373c8ba37135ccd9586c1881

@@ -1,85 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "t"
-                type {
-                  expression_pattern {
-                    expression {
-                      struct_type_literal {
-                        fields {
-                          name: "x"
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                        fields {
-                          name: "y"
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/05f7f32cfd698141c460623934959dd1a82f7109

@@ -1,191 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        destructor {
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "DESTRUCTOR A {0}"
-                          }
-                        }
-                        fields {
-                          simple_member_access {
-                            field: "n"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              if_statement {
-                condition {
-                  operator {
-                    op: Eq
-                    arguments {
-                      simple_member_access {
-                        field: "n"
-                        object {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 3
-                      }
-                    }
-                  }
-                }
-                then_block {
-                  statements {
-                    return_expression_statement {
-                      is_omitted_expression: true
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "DESTRUCTOR A: This message should not printed"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/075ffc3e7c80e173985255c88542930d8fed0613

@@ -1,75 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "Foo"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              compound_member_access {
-                object {
-                  struct_literal {
-                    fields {
-                      name: "m"
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                    fields {
-                      name: "n"
-                      expression {
-                        int_literal {
-                          value: 2
-                        }
-                      }
-                    }
-                  }
-                }
-                path {
-                  simple_member_access {
-                    field: "n"
-                    object {
-                      struct_type_literal {
-                        fields {
-                          name: "n"
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                        fields {
-                          name: "m"
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/07fe6d4b29d465ce688b6dd86b0571d1dfea03dd

@@ -1,155 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        function {
-          name {
-            name: "Origin"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Point"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Origin"
-                    object {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "x"
-                object {
-                  identifier {
-                    name: "p"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/081adaaf1729926b1089243ca595d1d8d2ab1fd5

@@ -1,46 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: true
-          }
-        }
-        statements {
-          return_var_statement {
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/086eb5f16b73ed72781d5579cdf16dcdc4e94744

@@ -1,148 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "TypeLike"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    type_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Convert"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  type_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Make"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          call {
-            function {
-              simple_member_access {
-                field: "Make"
-                object {
-                  identifier {
-                    name: "TypeLike"
-                  }
-                }
-              }
-            }
-            argument {
-              tuple_literal {
-              }
-            }
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0931a1fe829e600d14421a0fa4084d9c7176d01e

@@ -1,434 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        destructor {
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "DESTRUCTOR A {0}"
-                          }
-                        }
-                        fields {
-                          simple_member_access {
-                            field: "n"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "ident"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  bool_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          bool_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "x"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "ident_i32"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "x"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "i"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 0
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "d"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 4
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              call {
-                function {
-                  identifier {
-                    name: "ident"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      bool_literal {
-                        value: true
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                variable_definition {
-                  pattern {
-                    binding_pattern {
-                      name: "a"
-                      type {
-                        expression_pattern {
-                          expression {
-                            identifier {
-                              name: "A"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  init {
-                    struct_literal {
-                      fields {
-                        name: "n"
-                        expression {
-                          int_literal {
-                            value: 3
-                          }
-                        }
-                      }
-                    }
-                  }
-                  is_returned: false
-                }
-              }
-              statements {
-                if_statement {
-                  condition {
-                    bool_literal {
-                      value: true
-                    }
-                  }
-                  then_block {
-                    statements {
-                      variable_definition {
-                        pattern {
-                          binding_pattern {
-                            name: "b"
-                            type {
-                              expression_pattern {
-                                expression {
-                                  identifier {
-                                    name: "A"
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                        init {
-                          struct_literal {
-                            fields {
-                              name: "n"
-                              expression {
-                                int_literal {
-                                  value: 2
-                                }
-                              }
-                            }
-                          }
-                        }
-                        is_returned: false
-                      }
-                    }
-                    statements {
-                      expression_statement {
-                        expression {
-                          call {
-                            function {
-                              identifier {
-                                name: "ident_i32"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  int_literal {
-                                    value: 2
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    statements {
-                      if_statement {
-                        condition {
-                          operator {
-                            op: Eq
-                            arguments {
-                              call {
-                                function {
-                                  identifier {
-                                    name: "ident_i32"
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                    fields {
-                                      int_literal {
-                                        value: 0
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                            arguments {
-                              int_literal {
-                                value: 0
-                              }
-                            }
-                          }
-                        }
-                        then_block {
-                          statements {
-                            variable_definition {
-                              pattern {
-                                binding_pattern {
-                                  name: "c"
-                                  type {
-                                    expression_pattern {
-                                      expression {
-                                        identifier {
-                                          name: "A"
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                              init {
-                                struct_literal {
-                                  fields {
-                                    name: "n"
-                                    expression {
-                                      int_literal {
-                                        value: 1
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                              is_returned: false
-                            }
-                          }
-                          statements {
-                            return_expression_statement {
-                              expression {
-                                int_literal {
-                                  value: 2
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/09c98273d182befd2029eeb2d5913445abc23da3

@@ -1,294 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        function {
-          name {
-            name: "Origin"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Point"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "GetX"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Point"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "x"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "GetXY"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Point"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              tuple_literal {
-                fields {
-                  int_type_literal {
-                  }
-                }
-                fields {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  tuple_literal {
-                    fields {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "GetX"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "y"
-                        object {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Origin"
-                    object {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              index {
-                object {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "GetXY"
-                        object {
-                          identifier {
-                            name: "p"
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                offset {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/09ed6f05cf53cd5658b00434fbffeffff056d270

@@ -1,234 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        identifier {
-          name: "A"
-        }
-      }
-      interface {
-        where {
-          base {
-            call {
-              function {
-                identifier {
-                  name: "AddWith"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          clauses {
-            rewrite {
-              member_name: "Result"
-              replacement {
-                identifier {
-                  name: "A"
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Op"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "rhs"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "A"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "n"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "n"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            identifier {
-                              name: "rhs"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 5
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "a"
-              }
-            }
-            rhs {
-              operator {
-                op: Add
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "n"
-                object {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0a8b7f9961d982a063eb5287fa1fbc7f51e881ff

@@ -1,102 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 0
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          match {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-            clauses {
-              pattern {
-                expression_pattern {
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    assign {
-                      lhs {
-                        identifier {
-                          name: "x"
-                        }
-                      }
-                      rhs {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                      op: Plain
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              is_default: true
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0ad8ac2a88b1144df515cc60cb824fdef6c712ef

@@ -1,88 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "f"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    variable {
-      binding {
-        name: "y"
-        type {
-          expression_pattern {
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-      initializer {
-        call {
-          function {
-            identifier {
-              name: "f"
-            }
-          }
-          argument {
-            tuple_literal {
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "y"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0b8c017e8d7d8b363cb3d80dbfa45a8f917748e9

@@ -1,211 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Iface"
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "N"
-              type {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      param_pattern {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              where {
-                base {
-                  identifier {
-                    name: "Iface"
-                  }
-                }
-                clauses {
-                  equals {
-                    lhs {
-                      designator {
-                        name: "N"
-                      }
-                    }
-                    rhs {
-                      int_literal {
-                        value: 5
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Good"
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Bad"
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        identifier {
-          name: "Good"
-        }
-      }
-      interface {
-        where {
-          base {
-            identifier {
-              name: "Iface"
-            }
-          }
-          clauses {
-            rewrite {
-              member_name: "N"
-              replacement {
-                int_literal {
-                  value: 5
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        identifier {
-          name: "Bad"
-        }
-      }
-      interface {
-        where {
-          base {
-            identifier {
-              name: "Iface"
-            }
-          }
-          clauses {
-            rewrite {
-              member_name: "N"
-              replacement {
-                int_literal {
-                  value: 4
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "Good"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "Bad"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0c0ca21a65e25a0ed34b97458c4651e3e211fd7d

@@ -1,173 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    variable {
-      binding {
-        name: "call_count"
-        type {
-          expression_pattern {
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-      initializer {
-        int_literal {
-          value: 0
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "ReturnTrue"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          bool_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "call_count"
-              }
-            }
-            rhs {
-              operator {
-                op: Add
-                arguments {
-                  identifier {
-                    name: "call_count"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              bool_literal {
-                value: true
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "result"
-                type {
-                  expression_pattern {
-                    expression {
-                      bool_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: And
-                arguments {
-                  call {
-                    function {
-                      identifier {
-                        name: "ReturnTrue"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  call {
-                    function {
-                      identifier {
-                        name: "ReturnTrue"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              if_expression {
-                condition {
-                  identifier {
-                    name: "result"
-                  }
-                }
-                then_expression {
-                  identifier {
-                    name: "call_count"
-                  }
-                }
-                else_expression {
-                  operator {
-                    op: Neg
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0c1acfbf442273f3d4a3767b76a0ce511fb8e14f

@@ -1,48 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        qualifiers: "N"
-        name: "F"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0c86ef65371750e4a8b9cee11c8e47746abbda44

@@ -1,95 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  int_literal {
-                    value: 0
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                if_statement {
-                  condition {
-                    operator {
-                      op: Eq
-                      arguments {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                      arguments {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                  then_block {
-                    statements {
-                      return_expression_statement {
-                        expression {
-                          int_literal {
-                            value: 1
-                          }
-                        }
-                      }
-                    }
-                  }
-                  else_block {
-                    statements {
-                      return_expression_statement {
-                        expression {
-                          int_literal {
-                            value: 0
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0cb069aeca3e33c5b431baf6a25016982d6f17c9

@@ -1,626 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Addable"
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "k"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: InternalImpl
-      impl_type {
-        int_type_literal {
-        }
-      }
-      interface {
-        identifier {
-          name: "Addable"
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "k"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  operator {
-                    op: Add
-                    arguments {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                    arguments {
-                      identifier {
-                        name: "k"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Class"
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "GenericClass"
-      }
-      members {
-        variable {
-          binding {
-            name: "m"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Get"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "n"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "T"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "Add"
-                        object {
-                          simple_member_access {
-                            field: "m"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "n"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              identifier {
-                name: "Addable"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    alias {
-      name {
-        name: "ClassAlias"
-      }
-      target {
-        identifier {
-          name: "Class"
-        }
-      }
-    }
-  }
-  declarations {
-    alias {
-      name {
-        name: "GenericClassAlias"
-      }
-      target {
-        identifier {
-          name: "GenericClass"
-        }
-      }
-    }
-  }
-  declarations {
-    alias {
-      name {
-        name: "ClassSpecializationAlias"
-      }
-      target {
-        call {
-          function {
-            identifier {
-              name: "GenericClassAlias"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Class"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "ClassAlias"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              identifier {
-                name: "a"
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "c"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "GenericClass"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "m"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "d"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "GenericClassAlias"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              identifier {
-                name: "c"
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "e"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "ClassSpecializationAlias"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              identifier {
-                name: "c"
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "b.n: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "n"
-                        object {
-                          identifier {
-                            name: "b"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "d.Get(0): {0}"
-                      }
-                    }
-                    fields {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "Get"
-                            object {
-                              identifier {
-                                name: "d"
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_literal {
-                                value: 0
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "e.Get(1): {0}"
-                      }
-                    }
-                    fields {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "Get"
-                            object {
-                              identifier {
-                                name: "e"
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_literal {
-                                value: 1
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0d35d72cddc3a6d315e59e166bde555410df6c23

@@ -1,305 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "LazyNe"
-      }
-      members {
-        variable {
-          binding {
-            name: "v1"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "v2"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    bool_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Convert"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  bool_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      operator {
-                        op: NotEq
-                        arguments {
-                          simple_member_access {
-                            field: "v1"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                        arguments {
-                          simple_member_access {
-                            field: "v2"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Make"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "v1"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            fields {
-              binding_pattern {
-                name: "v2"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "v1"
-                      expression {
-                        identifier {
-                          name: "v1"
-                        }
-                      }
-                    }
-                    fields {
-                      name: "v2"
-                      expression {
-                        identifier {
-                          name: "v2"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  auto_pattern {
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 2
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          while_statement {
-            condition {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Make"
-                    object {
-                      identifier {
-                        name: "LazyNe"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "x"
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            body {
-              statements {
-                assign {
-                  lhs {
-                    identifier {
-                      name: "x"
-                    }
-                  }
-                  rhs {
-                    operator {
-                      op: Sub
-                      arguments {
-                        identifier {
-                          name: "x"
-                        }
-                      }
-                      arguments {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                  op: Plain
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "x"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0e6b20961131825faf926e7c56b0a285dc200c45

@@ -1,876 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Number"
-      }
-      members {
-        function {
-          name {
-            name: "Zero"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "other"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              identifier {
-                name: "Number"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        int_type_literal {
-        }
-      }
-      interface {
-        identifier {
-          name: "Number"
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Zero"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "other"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  operator {
-                    op: Add
-                    arguments {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                    arguments {
-                      identifier {
-                        name: "other"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        call {
-          function {
-            identifier {
-              name: "Point"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                identifier {
-                  name: "U"
-                }
-              }
-            }
-          }
-        }
-      }
-      interface {
-        identifier {
-          name: "Number"
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Zero"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "U"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Zero"
-                              object {
-                                identifier {
-                                  name: "U"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Zero"
-                              object {
-                                identifier {
-                                  name: "U"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    call {
-                      function {
-                        identifier {
-                          name: "Point"
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                          fields {
-                            identifier {
-                              name: "U"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "other"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              identifier {
-                                name: "U"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "U"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Add"
-                              object {
-                                simple_member_access {
-                                  field: "x"
-                                  object {
-                                    identifier {
-                                      name: "self"
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                              fields {
-                                simple_member_access {
-                                  field: "x"
-                                  object {
-                                    identifier {
-                                      name: "other"
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Add"
-                              object {
-                                simple_member_access {
-                                  field: "y"
-                                  object {
-                                    identifier {
-                                      name: "self"
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                              fields {
-                                simple_member_access {
-                                  field: "y"
-                                  object {
-                                    identifier {
-                                      name: "other"
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Sum"
-      }
-      deduced_parameters {
-        name: "E"
-        type {
-          identifier {
-            name: "Number"
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "E"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "E"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          identifier {
-            name: "E"
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "total"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "E"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Zero"
-                    object {
-                      identifier {
-                        name: "E"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "total"
-              }
-            }
-            rhs {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Add"
-                    object {
-                      identifier {
-                        name: "total"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "x"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "total"
-              }
-            }
-            rhs {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Add"
-                    object {
-                      identifier {
-                        name: "total"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "y"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "total"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "q"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 4
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "r"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  identifier {
-                    name: "Sum"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "p"
-                      }
-                    }
-                    fields {
-                      identifier {
-                        name: "q"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Sub
-                arguments {
-                  simple_member_access {
-                    field: "x"
-                    object {
-                      identifier {
-                        name: "r"
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  simple_member_access {
-                    field: "y"
-                    object {
-                      identifier {
-                        name: "r"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0e92e106654000c9dc5d0887df617586bbdf681f

@@ -1,262 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Frob"
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "Result"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "F"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Result"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Use"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          identifier {
-            name: "Frob"
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          simple_member_access {
-            field: "Result"
-            object {
-              identifier {
-                name: "T"
-              }
-            }
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "v"
-                type {
-                  expression_pattern {
-                    expression {
-                      simple_member_access {
-                        field: "Result"
-                        object {
-                          identifier {
-                            name: "T"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "F"
-                    object {
-                      identifier {
-                        name: "x"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "v"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: InternalImpl
-      impl_type {
-        int_type_literal {
-        }
-      }
-      interface {
-        where {
-          base {
-            identifier {
-              name: "Frob"
-            }
-          }
-          clauses {
-            rewrite {
-              member_name: "Result"
-              replacement {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "F"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Use"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0ec693754f4cad2f847af64da34d95de62086651

@@ -1,234 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        identifier {
-          name: "A"
-        }
-      }
-      interface {
-        where {
-          base {
-            call {
-              function {
-                identifier {
-                  name: "RightShiftWith"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          clauses {
-            rewrite {
-              member_name: "Result"
-              replacement {
-                identifier {
-                  name: "A"
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Op"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "rhs"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "A"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "n"
-                      expression {
-                        operator {
-                          op: BitShiftRight
-                          arguments {
-                            simple_member_access {
-                              field: "n"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            identifier {
-                              name: "rhs"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 5
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "a"
-              }
-            }
-            rhs {
-              operator {
-                op: BitShiftRight
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "n"
-                object {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0f4a5a4583189e307590798fd6a8535df7b43481

@@ -1,142 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "EmptyIdentifier"
-  }
-  is_api: false
-  declarations {
-    function {
-      name {
-        name: "apply"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      deduced_parameters {
-        name: "U"
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "f"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "EmptyIdentifier"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "U"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-        statements {
-          match {
-            expression {
-              index {
-                object {
-                  bool_literal {
-                    value: true
-                  }
-                }
-                offset {
-                  bool_literal {
-                    value: true
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "EmptyIdentifier"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          call {
-            function {
-              identifier {
-                name: "apply"
-              }
-            }
-            argument {
-              tuple_literal {
-                fields {
-                  bool_literal {
-                    value: true
-                  }
-                }
-                fields {
-                  bool_literal {
-                    value: true
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0f51fb075d9a0ec04bf29588ae89cbead328d51b

@@ -1,168 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        identifier {
-          name: "A"
-        }
-      }
-      interface {
-        call {
-          function {
-            identifier {
-              name: "ImplicitAs"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Convert"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "n"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 5
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: As
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0fa5dbb1cf634ded61edd83ac9aa1fb5435f2afb

@@ -1,199 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        identifier {
-          name: "A"
-        }
-      }
-      interface {
-        where {
-          base {
-            identifier {
-              name: "BitComplement"
-            }
-          }
-          clauses {
-            rewrite {
-              member_name: "Result"
-              replacement {
-                identifier {
-                  name: "A"
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Op"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "A"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "n"
-                      expression {
-                        operator {
-                          op: Complement
-                          arguments {
-                            simple_member_access {
-                              field: "n"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 5
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "a"
-              }
-            }
-            rhs {
-              operator {
-                op: Complement
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "n"
-                object {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/0ff1237b5ca488e8bcf62b899c96f2279dd8618a

@@ -1,582 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "identFn"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "x"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: Mod
-                arguments {
-                  int_literal {
-                    value: 7
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 2
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "x"
-              }
-            }
-            rhs {
-              operator {
-                op: Mod
-                arguments {
-                  operator {
-                    op: Mul
-                    arguments {
-                      int_literal {
-                        value: 3
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 3
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 3
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "x"
-              }
-            }
-            rhs {
-              operator {
-                op: Mod
-                arguments {
-                  operator {
-                    op: Add
-                    arguments {
-                      operator {
-                        op: Add
-                        arguments {
-                          operator {
-                            op: Add
-                            arguments {
-                              int_literal {
-                                value: 4
-                              }
-                            }
-                            arguments {
-                              int_literal {
-                                value: 4
-                              }
-                            }
-                          }
-                        }
-                        arguments {
-                          int_literal {
-                            value: 4
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 4
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Add
-                    arguments {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "x"
-              }
-            }
-            rhs {
-              operator {
-                op: Mod
-                arguments {
-                  int_literal {
-                    value: 15
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Add
-                    arguments {
-                      call {
-                        function {
-                          identifier {
-                            name: "identFn"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_literal {
-                                value: 2
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 4
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "x"
-              }
-            }
-            rhs {
-              operator {
-                op: Mod
-                arguments {
-                  operator {
-                    op: Neg
-                    arguments {
-                      int_literal {
-                        value: 15
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 7
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Neg
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 5
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "x"
-              }
-            }
-            rhs {
-              operator {
-                op: Mod
-                arguments {
-                  int_literal {
-                    value: 15
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Neg
-                    arguments {
-                      int_literal {
-                        value: 7
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 6
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "x"
-              }
-            }
-            rhs {
-              operator {
-                op: Mod
-                arguments {
-                  operator {
-                    op: Neg
-                    arguments {
-                      int_literal {
-                        value: 15
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Neg
-                    arguments {
-                      call {
-                        function {
-                          identifier {
-                            name: "identFn"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_literal {
-                                value: 7
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Neg
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 7
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/10b3ac55167965078be7c7e32a3b9ac35742ebab

@@ -1,104 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 1
-              }
-            }
-            is_returned: true
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              bool_literal {
-                value: true
-              }
-            }
-            then_block {
-              statements {
-                variable_definition {
-                  pattern {
-                    binding_pattern {
-                      name: "x"
-                      type {
-                        expression_pattern {
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  init {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                  is_returned: false
-                }
-              }
-              statements {
-                return_var_statement {
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "x"
-              }
-            }
-            rhs {
-              int_literal {
-                value: 3
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          return_var_statement {
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/10bc53bafd07b8ea7cd8e5321d4720b0c46db012

@@ -1,199 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    alias {
-      name {
-        name: "TypeAlias"
-      }
-      target {
-        int_type_literal {
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          identifier {
-            name: "TypeAlias"
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "n"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "TypeAlias"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 1
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "m"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              identifier {
-                name: "n"
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: AddressOf
-                arguments {
-                  identifier {
-                    name: "n"
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "q"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "TypeAlias"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: AddressOf
-                arguments {
-                  identifier {
-                    name: "m"
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Add
-                arguments {
-                  operator {
-                    op: Add
-                    arguments {
-                      operator {
-                        op: Add
-                        arguments {
-                          operator {
-                            op: Deref
-                            arguments {
-                              identifier {
-                                name: "p"
-                              }
-                            }
-                          }
-                        }
-                        arguments {
-                          operator {
-                            op: Deref
-                            arguments {
-                              identifier {
-                                name: "q"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      identifier {
-                        name: "m"
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "n"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/10bf4210ca99eb159f3e5e11b69ce67e4ec2e410

@@ -1,683 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Vector"
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Scale"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "v"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        identifier {
-          name: "Point"
-        }
-      }
-      interface {
-        identifier {
-          name: "Vector"
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Point"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Point"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "b"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "b"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Scale"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Point"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "v"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Point"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        operator {
-                          op: Mul
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            identifier {
-                              name: "v"
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        operator {
-                          op: Mul
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            identifier {
-                              name: "v"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "AddAndScaleGeneric"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          identifier {
-            name: "Vector"
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "s"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          identifier {
-            name: "T"
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "m"
-                type {
-                  auto_pattern {
-                  }
-                }
-              }
-            }
-            init {
-              simple_member_access {
-                field: "Add"
-                object {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "n"
-                type {
-                  auto_pattern {
-                  }
-                }
-              }
-            }
-            init {
-              simple_member_access {
-                field: "Scale"
-                object {
-                  call {
-                    function {
-                      identifier {
-                        name: "m"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "b"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "n"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "s"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 4
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  identifier {
-                    name: "AddAndScaleGeneric"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "a"
-                      }
-                    }
-                    fields {
-                      identifier {
-                        name: "b"
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 5
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Sub
-                arguments {
-                  simple_member_access {
-                    field: "x"
-                    object {
-                      identifier {
-                        name: "p"
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 15
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1111b8be1131541ec8c3a7b9c8a2e5e2cc634ab0

@@ -1,127 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "C"
-      }
-      members {
-        function {
-          name {
-            name: "Create"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "a"
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "c"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "C"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Create"
-                    object {
-                      identifier {
-                        name: "C"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/11129722dc448b2011c92f79dc750129eff3858b

@@ -1,74 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "y"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              identifier {
-                name: "x"
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "x"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/117ed6ced083ede3e318697fc56548fabe03039e

@@ -1,512 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "ManyTypes"
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T0"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T1"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T2"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T3"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T4"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T5"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T6"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T7"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T8"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "T9"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      deduced_parameters {
-        name: "M"
-        type {
-          where {
-            base {
-              identifier {
-                name: "ManyTypes"
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T0"
-                replacement {
-                  designator {
-                    name: "T1"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T1"
-                replacement {
-                  designator {
-                    name: "T2"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T2"
-                replacement {
-                  designator {
-                    name: "T3"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T3"
-                replacement {
-                  designator {
-                    name: "T4"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T4"
-                replacement {
-                  designator {
-                    name: "T5"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T5"
-                replacement {
-                  designator {
-                    name: "T6"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T6"
-                replacement {
-                  designator {
-                    name: "T7"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T7"
-                replacement {
-                  designator {
-                    name: "T8"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T8"
-                replacement {
-                  designator {
-                    name: "T9"
-                  }
-                }
-              }
-            }
-            clauses {
-              rewrite {
-                member_name: "T9"
-                replacement {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "m"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "M"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "v"
-                type {
-                  expression_pattern {
-                    expression {
-                      simple_member_access {
-                        field: "T0"
-                        object {
-                          identifier {
-                            name: "M"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 1
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "v"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "C"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            where {
-              base {
-                identifier {
-                  name: "ManyTypes"
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T0"
-                  replacement {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T1"
-                  replacement {
-                    designator {
-                      name: "T0"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T2"
-                  replacement {
-                    designator {
-                      name: "T1"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T3"
-                  replacement {
-                    designator {
-                      name: "T2"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T4"
-                  replacement {
-                    designator {
-                      name: "T3"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T5"
-                  replacement {
-                    designator {
-                      name: "T4"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T6"
-                  replacement {
-                    designator {
-                      name: "T5"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T7"
-                  replacement {
-                    designator {
-                      name: "T6"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T8"
-                  replacement {
-                    designator {
-                      name: "T7"
-                    }
-                  }
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "T9"
-                  replacement {
-                    designator {
-                      name: "T8"
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "c"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "C"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1191f8daa134f3932d68bd24f270b2286a87560b

@@ -1,76 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    namespace {
-      name {
-        name: "N"
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        qualifiers: "N"
-        name: "F"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/119a0b3341f7032a48ccdded931a1c2fccdd6f52

@@ -1,145 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "t1"
-                type {
-                  expression_pattern {
-                    expression {
-                      tuple_literal {
-                        fields {
-                          int_type_literal {
-                          }
-                        }
-                        fields {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              tuple_literal {
-                fields {
-                  int_literal {
-                    value: 5
-                  }
-                }
-                fields {
-                  int_literal {
-                    value: 2
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "t2"
-                type {
-                  expression_pattern {
-                    expression {
-                      tuple_literal {
-                        fields {
-                          int_type_literal {
-                          }
-                        }
-                        fields {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              tuple_literal {
-                fields {
-                  int_literal {
-                    value: 5
-                  }
-                }
-                fields {
-                  int_literal {
-                    value: 2
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  identifier {
-                    name: "t1"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "t2"
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 0
-                    }
-                  }
-                }
-              }
-            }
-            else_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/11e091578ab1fee7bb92cf00355ff51be89cf801

@@ -1,186 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "AddInt"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "ret"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: Add
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            is_returned: true
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                variable_definition {
-                  pattern {
-                    binding_pattern {
-                      name: "ret2"
-                      type {
-                        expression_pattern {
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  init {
-                    operator {
-                      op: Add
-                      arguments {
-                        identifier {
-                          name: "a"
-                        }
-                      }
-                      arguments {
-                        identifier {
-                          name: "b"
-                        }
-                      }
-                    }
-                  }
-                  is_returned: true
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_var_statement {
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "AddInt"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/123fb6fa380b035e905b35aab5af9e28b936470f

@@ -1,105 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "id"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          identifier {
-            name: "T"
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Add
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "id"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/13165465925de647ee3bd1d663a7e406b084a182

@@ -1,335 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "C"
-      }
-      members {
-        function {
-          name {
-            name: "Method1"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "Class C"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "GetValue"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "value"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "value"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "D"
-      }
-      members {
-        function {
-          name {
-            name: "Method1"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "Class D"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "value"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "d"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "D"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "value"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-                fields {
-                  name: "base"
-                  expression {
-                    struct_literal {
-                      fields {
-                        name: "value"
-                        expression {
-                          int_literal {
-                            value: 1
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Method1"
-                    object {
-                      identifier {
-                        name: "d"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "d.value = {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "value"
-                        object {
-                          identifier {
-                            name: "d"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "d.GetValue() = {0}"
-                      }
-                    }
-                    fields {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "GetValue"
-                            object {
-                              identifier {
-                                name: "d"
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/13699d187869d480a856deeb58a9b72a42414510

@@ -1,203 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Foo"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Auto
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "ret"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: Add
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            is_returned: true
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                assign {
-                  lhs {
-                    identifier {
-                      name: "ret"
-                    }
-                  }
-                  rhs {
-                    operator {
-                      op: Sub
-                      arguments {
-                        identifier {
-                          name: "b"
-                        }
-                      }
-                      arguments {
-                        identifier {
-                          name: "a"
-                        }
-                      }
-                    }
-                  }
-                  op: Plain
-                }
-              }
-              statements {
-                return_var_statement {
-                }
-              }
-            }
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "ret"
-              }
-            }
-            rhs {
-              operator {
-                op: Sub
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          return_var_statement {
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Foo"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/137763417c6bb89b2f19ce90364ed912e997a51e

@@ -1,92 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "EmptyIdentifier"
-  }
-  is_api: false
-  declarations {
-    function {
-      name {
-        name: "test"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "test"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 1
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/138b2d121b29802db4a2e37a2d563bc6ab8c5aef

@@ -1,513 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "MyAddWith"
-      }
-      members {
-        function {
-          name {
-            name: "Op"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: InternalImpl
-      impl_type {
-        identifier {
-          name: "Point"
-        }
-      }
-      interface {
-        call {
-          function {
-            identifier {
-              name: "MyAddWith"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                identifier {
-                  name: "Self"
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Op"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Point"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Point"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "b"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "b"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "DoAddGeneric"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      deduced_parameters {
-        name: "U"
-        type {
-          call {
-            function {
-              identifier {
-                name: "MyAddWith"
-              }
-            }
-            argument {
-              tuple_literal {
-                fields {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "U"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          identifier {
-            name: "U"
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Op"
-                    object {
-                      identifier {
-                        name: "a"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "b"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 4
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  identifier {
-                    name: "DoAddGeneric"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "a"
-                      }
-                    }
-                    fields {
-                      identifier {
-                        name: "b"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Sub
-                arguments {
-                  operator {
-                    op: Sub
-                    arguments {
-                      simple_member_access {
-                        field: "x"
-                        object {
-                          identifier {
-                            name: "p"
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      simple_member_access {
-                        field: "y"
-                        object {
-                          identifier {
-                            name: "p"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 3
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1390a7598274c8a07a7db037d164e7ba04fa084e

@@ -1,127 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Bad"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  struct_type_literal {
-                    fields {
-                      name: "a"
-                      expression {
-                        int_type_literal {
-                        }
-                      }
-                    }
-                    fields {
-                      name: "b"
-                      expression {
-                        identifier {
-                          name: "T"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Bad"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      struct_literal {
-                        fields {
-                          name: "b"
-                          expression {
-                            int_literal {
-                              value: 5
-                            }
-                          }
-                        }
-                        fields {
-                          name: "a"
-                          expression {
-                            int_literal {
-                              value: 7
-                            }
-                          }
-                        }
-                        fields {
-                          name: "c"
-                          expression {
-                            int_literal {
-                              value: 2
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/13dcb5a00f09e0ec0a7fd03fb720bdad03c495f1

@@ -1,128 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Foo"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              tuple_pattern {
-                fields {
-                  binding_pattern {
-                    name: "x"
-                    type {
-                      expression_pattern {
-                        expression {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                fields {
-                  binding_pattern {
-                    name: "y"
-                    type {
-                      expression_pattern {
-                        expression {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          while_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  call {
-                    function {
-                      identifier {
-                        name: "Foo"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-            body {
-              statements {
-                assign {
-                  lhs {
-                    identifier {
-                      name: "y"
-                    }
-                  }
-                  rhs {
-                    identifier {
-                      name: "x"
-                    }
-                  }
-                  op: Plain
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/15005ba56570844e2a9ab20299631f8ffedc38c6

@@ -1,69 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "C"
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          operator {
-            op: BitwiseAnd
-            arguments {
-              type_type_literal {
-              }
-            }
-            arguments {
-              identifier {
-                name: "C"
-              }
-            }
-          }
-        }
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Omitted
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/151b851709a6cb57bbee182c3220b59c87027ec4

@@ -1,151 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "t1"
-                type {
-                  expression_pattern {
-                    expression {
-                      tuple_literal {
-                        fields {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              tuple_literal {
-                fields {
-                  int_literal {
-                    value: 5
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "t2"
-                type {
-                  expression_pattern {
-                    expression {
-                      tuple_literal {
-                        fields {
-                          int_type_literal {
-                          }
-                        }
-                        fields {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              tuple_literal {
-                fields {
-                  int_literal {
-                    value: 2
-                  }
-                }
-                fields {
-                  int_literal {
-                    value: 3
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Sub
-                arguments {
-                  operator {
-                    op: Sub
-                    arguments {
-                      index {
-                        object {
-                          identifier {
-                            name: "t1"
-                          }
-                        }
-                        offset {
-                          int_literal {
-                            value: 0
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      index {
-                        object {
-                          identifier {
-                            name: "t2"
-                          }
-                        }
-                        offset {
-                          int_literal {
-                            value: 0
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  index {
-                    object {
-                      identifier {
-                        name: "t2"
-                      }
-                    }
-                    offset {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/15bd86b0412443771aa00da617795aa0e5c64185

@@ -1,484 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "One"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "One"
-            }
-          }
-          interface {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Convert"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Two"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "Two"
-            }
-          }
-          interface {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Convert"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "N"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "N"
-            }
-          }
-          interface {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Convert"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      simple_member_access {
-                        field: "n"
-                        object {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Get"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "c"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Add
-                arguments {
-                  operator {
-                    op: Add
-                    arguments {
-                      operator {
-                        op: Mul
-                        arguments {
-                          int_literal {
-                            value: 100
-                          }
-                        }
-                        arguments {
-                          identifier {
-                            name: "a"
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      operator {
-                        op: Mul
-                        arguments {
-                          int_literal {
-                            value: 10
-                          }
-                        }
-                        arguments {
-                          identifier {
-                            name: "b"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "c"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "i"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "One"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "ii"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Two"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "iii"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "N"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Get"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "i"
-                      }
-                    }
-                    fields {
-                      identifier {
-                        name: "ii"
-                      }
-                    }
-                    fields {
-                      identifier {
-                        name: "iii"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/15ce7e6d7d3131c20c8e85783a76e9405dc43ac5

@@ -1,74 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  int_literal {
-                    value: 0
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-            else_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 0
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/17310ae919b40b6ca070de923c138a8d75df0204

@@ -1,414 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        function {
-          name {
-            name: "FunctionA"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "aa"
-            type {
-              expression_pattern {
-                expression {
-                  string_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "B"
-      }
-      members {
-        function {
-          name {
-            name: "FunctionB"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "C"
-      }
-      members {
-        function {
-          name {
-            name: "FunctionC"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "c"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "c"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "C"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "base"
-                  expression {
-                    struct_literal {
-                      fields {
-                        name: "base"
-                        expression {
-                          struct_literal {
-                            fields {
-                              name: "aa"
-                              expression {
-                                string_literal {
-                                  value: "A"
-                                }
-                              }
-                            }
-                            fields {
-                              name: "a"
-                              expression {
-                                int_literal {
-                                  value: 1
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        name: "b"
-                        expression {
-                          int_literal {
-                            value: 2
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                fields {
-                  name: "c"
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "FunctionA"
-                    object {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "FunctionB"
-                    object {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "FunctionC"
-                    object {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      simple_member_access {
-                        field: "aa"
-                        object {
-                          identifier {
-                            name: "c"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "c.a: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "a"
-                        object {
-                          identifier {
-                            name: "c"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "c.b: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "b"
-                        object {
-                          identifier {
-                            name: "c"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "c.c: {0}"
-                      }
-                    }
-                    fields {
-                      simple_member_access {
-                        field: "c"
-                        object {
-                          identifier {
-                            name: "c"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/17a00f823161d813cdcaa73fe8a860bfbfa1266c

@@ -1,192 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "IntDiff"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                variable_definition {
-                  pattern {
-                    binding_pattern {
-                      name: "ret"
-                      type {
-                        expression_pattern {
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  init {
-                    operator {
-                      op: Sub
-                      arguments {
-                        identifier {
-                          name: "a"
-                        }
-                      }
-                      arguments {
-                        identifier {
-                          name: "b"
-                        }
-                      }
-                    }
-                  }
-                  is_returned: true
-                }
-              }
-              statements {
-                return_var_statement {
-                }
-              }
-            }
-            else_block {
-              statements {
-                variable_definition {
-                  pattern {
-                    binding_pattern {
-                      name: "ret2"
-                      type {
-                        expression_pattern {
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  init {
-                    operator {
-                      op: Sub
-                      arguments {
-                        identifier {
-                          name: "b"
-                        }
-                      }
-                      arguments {
-                        identifier {
-                          name: "a"
-                        }
-                      }
-                    }
-                  }
-                  is_returned: true
-                }
-              }
-              statements {
-                return_var_statement {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "IntDiff"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/181b96bd90fda933ccc0f44032fc3e7ac753c091

@@ -1,265 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "HasAssoc"
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "Assoc"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "X"
-      }
-      members {
-        impl {
-          kind: ExternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            where {
-              base {
-                identifier {
-                  name: "HasAssoc"
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "Assoc"
-                  replacement {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    alias {
-      name {
-        name: "WithoutRewrite"
-      }
-      target {
-        where {
-          base {
-            identifier {
-              name: "HasAssoc"
-            }
-          }
-          clauses {
-            equals {
-              lhs {
-                designator {
-                  name: "Assoc"
-                }
-              }
-              rhs {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    alias {
-      name {
-        name: "WithRewrite"
-      }
-      target {
-        where {
-          base {
-            identifier {
-              name: "HasAssoc"
-            }
-          }
-          clauses {
-            rewrite {
-              member_name: "Assoc"
-              replacement {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          identifier {
-            name: "WithRewrite"
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      compound_member_access {
-                        object {
-                          identifier {
-                            name: "T"
-                          }
-                        }
-                        path {
-                          simple_member_access {
-                            field: "Assoc"
-                            object {
-                              identifier {
-                                name: "WithoutRewrite"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 1
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "a"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "X"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "x"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1820cf28f49d1ee771fc53c74743e545529b509c

@@ -1,184 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "Foo"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "X"
-      }
-      members {
-        function {
-          name {
-            name: "F"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "o"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "n"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "n"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            simple_member_access {
-                              field: "n"
-                              object {
-                                identifier {
-                                  name: "o"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "n"
-                object {
-                  call {
-                    function {
-                      compound_member_access {
-                        object {
-                          struct_literal {
-                            fields {
-                              name: "n"
-                              expression {
-                                int_literal {
-                                  value: 1
-                                }
-                              }
-                            }
-                          }
-                        }
-                        path {
-                          simple_member_access {
-                            field: "F"
-                            object {
-                              identifier {
-                                name: "X"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          struct_literal {
-                            fields {
-                              name: "n"
-                              expression {
-                                int_literal {
-                                  value: 2
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/189f5602a95e12265aaf65183c1d552f0663b36c

@@ -1,266 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        function {
-          name {
-            name: "Origin"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "zero"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        identifier {
-                          name: "zero"
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        identifier {
-                          name: "zero"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "GetX"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "T"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "x"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Origin"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "GetX"
-                    object {
-                      identifier {
-                        name: "p"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/18e4b0c01d7c2527f3a3d682b114ec5afe7d539b

@@ -1,310 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "FirstOfTwoPoints"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "T"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Point"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "T"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          call {
-            function {
-              identifier {
-                name: "Point"
-              }
-            }
-            argument {
-              tuple_literal {
-                fields {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "a"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 0
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "q"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              bool_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    bool_literal {
-                      value: true
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    bool_literal {
-                      value: false
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "x"
-                object {
-                  call {
-                    function {
-                      identifier {
-                        name: "FirstOfTwoPoints"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "p"
-                          }
-                        }
-                        fields {
-                          identifier {
-                            name: "q"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1983eb50faba24986c9fefe94e372fb2eaa35445

@@ -1,172 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Optional"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              string_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Create"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "Optional"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              string_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "Hallo Welt"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              call {
-                function {
-                  simple_member_access {
-                    field: "HasValue"
-                    object {
-                      identifier {
-                        name: "x"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                expression_statement {
-                  expression {
-                    call {
-                      function {
-                        identifier {
-                          name: "Print"
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                          fields {
-                            call {
-                              function {
-                                simple_member_access {
-                                  field: "Get"
-                                  object {
-                                    identifier {
-                                      name: "x"
-                                    }
-                                  }
-                                }
-                              }
-                              argument {
-                                tuple_literal {
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 0
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Neg
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/199d526c94d7b59769c7bea1306f67bdd4767fac

@@ -1,361 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        class_declaration {
-          name {
-            name: "B"
-          }
-          members {
-            destructor {
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              body {
-                statements {
-                  expression_statement {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Print"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              string_literal {
-                                value: "DESTRUCTOR B {0}"
-                              }
-                            }
-                            fields {
-                              simple_member_access {
-                                field: "n"
-                                object {
-                                  identifier {
-                                    name: "self"
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Create"
-              }
-              param_pattern {
-                fields {
-                  binding_pattern {
-                    name: "x"
-                    type {
-                      expression_pattern {
-                        expression {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              return_term {
-                kind: Expression
-                type {
-                  identifier {
-                    name: "B"
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      struct_literal {
-                        fields {
-                          name: "n"
-                          expression {
-                            identifier {
-                              name: "x"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            variable {
-              binding {
-                name: "n"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        destructor {
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "DESTRUCTOR A {0}"
-                          }
-                        }
-                        fields {
-                          simple_member_access {
-                            field: "n"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Create"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "A"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "n"
-                      expression {
-                        identifier {
-                          name: "x"
-                        }
-                      }
-                    }
-                    fields {
-                      name: "b"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Create"
-                              object {
-                                identifier {
-                                  name: "B"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                              fields {
-                                int_literal {
-                                  value: 2
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "B"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Create"
-                    object {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1aa8b45819d453372d67a450012c501fd74893ec

@@ -1,3955 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Node"
-      }
-      members {
-        function {
-          name {
-            name: "Create"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "value"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Node"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "value"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Create"
-                              object {
-                                call {
-                                  function {
-                                    identifier {
-                                      name: "Optional"
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        identifier {
-                                          name: "T"
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                              fields {
-                                identifier {
-                                  name: "value"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "next"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "CreateEmpty"
-                              object {
-                                call {
-                                  function {
-                                    identifier {
-                                      name: "Optional"
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        operator {
-                                          op: Ptr
-                                          arguments {
-                                            call {
-                                              function {
-                                                identifier {
-                                                  name: "Node"
-                                                }
-                                              }
-                                              argument {
-                                                tuple_literal {
-                                                  fields {
-                                                    identifier {
-                                                      name: "T"
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "prev"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "CreateEmpty"
-                              object {
-                                call {
-                                  function {
-                                    identifier {
-                                      name: "Optional"
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        operator {
-                                          op: Ptr
-                                          arguments {
-                                            call {
-                                              function {
-                                                identifier {
-                                                  name: "Node"
-                                                }
-                                              }
-                                              argument {
-                                                tuple_literal {
-                                                  fields {
-                                                    identifier {
-                                                      name: "T"
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "set_next"
-          }
-          self_pattern {
-            addr_pattern {
-              binding_pattern {
-                name: "self"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "Self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "n"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Optional"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              operator {
-                                op: Ptr
-                                arguments {
-                                  call {
-                                    function {
-                                      identifier {
-                                        name: "Node"
-                                      }
-                                    }
-                                    argument {
-                                      tuple_literal {
-                                        fields {
-                                          identifier {
-                                            name: "T"
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "next"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  identifier {
-                    name: "n"
-                  }
-                }
-                op: Plain
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "set_prev"
-          }
-          self_pattern {
-            addr_pattern {
-              binding_pattern {
-                name: "self"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "Self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "n"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Optional"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              operator {
-                                op: Ptr
-                                arguments {
-                                  call {
-                                    function {
-                                      identifier {
-                                        name: "Node"
-                                      }
-                                    }
-                                    argument {
-                                      tuple_literal {
-                                        fields {
-                                          identifier {
-                                            name: "T"
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "prev"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  identifier {
-                    name: "n"
-                  }
-                }
-                op: Plain
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "value"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Optional"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "T"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "next"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Optional"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          operator {
-                            op: Ptr
-                            arguments {
-                              call {
-                                function {
-                                  identifier {
-                                    name: "Node"
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                    fields {
-                                      identifier {
-                                        name: "T"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "prev"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Optional"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          operator {
-                            op: Ptr
-                            arguments {
-                              call {
-                                function {
-                                  identifier {
-                                    name: "Node"
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                    fields {
-                                      identifier {
-                                        name: "T"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "LinkedList"
-      }
-      members {
-        function {
-          name {
-            name: "Create"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "LinkedList"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "head"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "CreateEmpty"
-                              object {
-                                call {
-                                  function {
-                                    identifier {
-                                      name: "Optional"
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        operator {
-                                          op: Ptr
-                                          arguments {
-                                            call {
-                                              function {
-                                                identifier {
-                                                  name: "Node"
-                                                }
-                                              }
-                                              argument {
-                                                tuple_literal {
-                                                  fields {
-                                                    identifier {
-                                                      name: "T"
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "tail"
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "CreateEmpty"
-                              object {
-                                call {
-                                  function {
-                                    identifier {
-                                      name: "Optional"
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        operator {
-                                          op: Ptr
-                                          arguments {
-                                            call {
-                                              function {
-                                                identifier {
-                                                  name: "Node"
-                                                }
-                                              }
-                                              argument {
-                                                tuple_literal {
-                                                  fields {
-                                                    identifier {
-                                                      name: "T"
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "len"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "PushBack"
-          }
-          self_pattern {
-            addr_pattern {
-              binding_pattern {
-                name: "self"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "Self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "value"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "len"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  operator {
-                    op: Add
-                    arguments {
-                      simple_member_access {
-                        field: "len"
-                        object {
-                          operator {
-                            op: Deref
-                            arguments {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-                op: Plain
-              }
-            }
-            statements {
-              if_statement {
-                condition {
-                  operator {
-                    op: Not
-                    arguments {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "HasValue"
-                            object {
-                              simple_member_access {
-                                field: "head"
-                                object {
-                                  operator {
-                                    op: Deref
-                                    arguments {
-                                      identifier {
-                                        name: "self"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                then_block {
-                  statements {
-                    assign {
-                      lhs {
-                        simple_member_access {
-                          field: "head"
-                          object {
-                            operator {
-                              op: Deref
-                              arguments {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      rhs {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Create"
-                              object {
-                                call {
-                                  function {
-                                    identifier {
-                                      name: "Optional"
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        operator {
-                                          op: Ptr
-                                          arguments {
-                                            call {
-                                              function {
-                                                identifier {
-                                                  name: "Node"
-                                                }
-                                              }
-                                              argument {
-                                                tuple_literal {
-                                                  fields {
-                                                    identifier {
-                                                      name: "T"
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                              fields {
-                                call {
-                                  function {
-                                    simple_member_access {
-                                      field: "New"
-                                      object {
-                                        identifier {
-                                          name: "heap"
-                                        }
-                                      }
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        call {
-                                          function {
-                                            simple_member_access {
-                                              field: "Create"
-                                              object {
-                                                call {
-                                                  function {
-                                                    identifier {
-                                                      name: "Node"
-                                                    }
-                                                  }
-                                                  argument {
-                                                    tuple_literal {
-                                                      fields {
-                                                        identifier {
-                                                          name: "T"
-                                                        }
-                                                      }
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                          argument {
-                                            tuple_literal {
-                                              fields {
-                                                identifier {
-                                                  name: "value"
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      op: Plain
-                    }
-                  }
-                  statements {
-                    assign {
-                      lhs {
-                        simple_member_access {
-                          field: "tail"
-                          object {
-                            operator {
-                              op: Deref
-                              arguments {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      rhs {
-                        simple_member_access {
-                          field: "head"
-                          object {
-                            operator {
-                              op: Deref
-                              arguments {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      op: Plain
-                    }
-                  }
-                  statements {
-                    return_expression_statement {
-                      is_omitted_expression: true
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              variable_definition {
-                pattern {
-                  binding_pattern {
-                    name: "last"
-                    type {
-                      expression_pattern {
-                        expression {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                init {
-                  simple_member_access {
-                    field: "tail"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                is_returned: false
-              }
-            }
-            statements {
-              variable_definition {
-                pattern {
-                  binding_pattern {
-                    name: "last_value"
-                    type {
-                      expression_pattern {
-                        expression {
-                          operator {
-                            op: Ptr
-                            arguments {
-                              call {
-                                function {
-                                  identifier {
-                                    name: "Node"
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                    fields {
-                                      identifier {
-                                        name: "T"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                init {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "Get"
-                        object {
-                          identifier {
-                            name: "last"
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                is_returned: false
-              }
-            }
-            statements {
-              variable_definition {
-                pattern {
-                  binding_pattern {
-                    name: "v_wrapped"
-                    type {
-                      expression_pattern {
-                        expression {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                init {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "Create"
-                        object {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          call {
-                            function {
-                              simple_member_access {
-                                field: "New"
-                                object {
-                                  identifier {
-                                    name: "heap"
-                                  }
-                                }
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  call {
-                                    function {
-                                      simple_member_access {
-                                        field: "Create"
-                                        object {
-                                          call {
-                                            function {
-                                              identifier {
-                                                name: "Node"
-                                              }
-                                            }
-                                            argument {
-                                              tuple_literal {
-                                                fields {
-                                                  identifier {
-                                                    name: "T"
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                    argument {
-                                      tuple_literal {
-                                        fields {
-                                          identifier {
-                                            name: "value"
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                is_returned: false
-              }
-            }
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "set_next"
-                        object {
-                          operator {
-                            op: Deref
-                            arguments {
-                              identifier {
-                                name: "last_value"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "v_wrapped"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "set_prev"
-                        object {
-                          operator {
-                            op: Deref
-                            arguments {
-                              call {
-                                function {
-                                  simple_member_access {
-                                    field: "Get"
-                                    object {
-                                      identifier {
-                                        name: "v_wrapped"
-                                      }
-                                    }
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "last"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "tail"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  identifier {
-                    name: "v_wrapped"
-                  }
-                }
-                op: Plain
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "PushFront"
-          }
-          self_pattern {
-            addr_pattern {
-              binding_pattern {
-                name: "self"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "Self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "value"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "len"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  operator {
-                    op: Add
-                    arguments {
-                      simple_member_access {
-                        field: "len"
-                        object {
-                          operator {
-                            op: Deref
-                            arguments {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-                op: Plain
-              }
-            }
-            statements {
-              if_statement {
-                condition {
-                  operator {
-                    op: Not
-                    arguments {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "HasValue"
-                            object {
-                              simple_member_access {
-                                field: "head"
-                                object {
-                                  operator {
-                                    op: Deref
-                                    arguments {
-                                      identifier {
-                                        name: "self"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                then_block {
-                  statements {
-                    assign {
-                      lhs {
-                        simple_member_access {
-                          field: "head"
-                          object {
-                            operator {
-                              op: Deref
-                              arguments {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      rhs {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Create"
-                              object {
-                                call {
-                                  function {
-                                    identifier {
-                                      name: "Optional"
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        operator {
-                                          op: Ptr
-                                          arguments {
-                                            call {
-                                              function {
-                                                identifier {
-                                                  name: "Node"
-                                                }
-                                              }
-                                              argument {
-                                                tuple_literal {
-                                                  fields {
-                                                    identifier {
-                                                      name: "T"
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                              fields {
-                                call {
-                                  function {
-                                    simple_member_access {
-                                      field: "New"
-                                      object {
-                                        identifier {
-                                          name: "heap"
-                                        }
-                                      }
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                      fields {
-                                        call {
-                                          function {
-                                            simple_member_access {
-                                              field: "Create"
-                                              object {
-                                                call {
-                                                  function {
-                                                    identifier {
-                                                      name: "Node"
-                                                    }
-                                                  }
-                                                  argument {
-                                                    tuple_literal {
-                                                      fields {
-                                                        identifier {
-                                                          name: "T"
-                                                        }
-                                                      }
-                                                    }
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                          argument {
-                                            tuple_literal {
-                                              fields {
-                                                identifier {
-                                                  name: "value"
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      op: Plain
-                    }
-                  }
-                  statements {
-                    assign {
-                      lhs {
-                        simple_member_access {
-                          field: "tail"
-                          object {
-                            operator {
-                              op: Deref
-                              arguments {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      rhs {
-                        simple_member_access {
-                          field: "head"
-                          object {
-                            operator {
-                              op: Deref
-                              arguments {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      op: Plain
-                    }
-                  }
-                  statements {
-                    return_expression_statement {
-                      is_omitted_expression: true
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              variable_definition {
-                pattern {
-                  binding_pattern {
-                    name: "v_wrapped"
-                    type {
-                      expression_pattern {
-                        expression {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                init {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "Create"
-                        object {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          call {
-                            function {
-                              simple_member_access {
-                                field: "New"
-                                object {
-                                  identifier {
-                                    name: "heap"
-                                  }
-                                }
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  call {
-                                    function {
-                                      simple_member_access {
-                                        field: "Create"
-                                        object {
-                                          call {
-                                            function {
-                                              identifier {
-                                                name: "Node"
-                                              }
-                                            }
-                                            argument {
-                                              tuple_literal {
-                                                fields {
-                                                  identifier {
-                                                    name: "T"
-                                                  }
-                                                }
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                    argument {
-                                      tuple_literal {
-                                        fields {
-                                          identifier {
-                                            name: "value"
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                is_returned: false
-              }
-            }
-            statements {
-              variable_definition {
-                pattern {
-                  binding_pattern {
-                    name: "current_head"
-                    type {
-                      expression_pattern {
-                        expression {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                init {
-                  simple_member_access {
-                    field: "head"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                is_returned: false
-              }
-            }
-            statements {
-              variable_definition {
-                pattern {
-                  binding_pattern {
-                    name: "current_head_value"
-                    type {
-                      expression_pattern {
-                        expression {
-                          operator {
-                            op: Ptr
-                            arguments {
-                              call {
-                                function {
-                                  identifier {
-                                    name: "Node"
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                    fields {
-                                      identifier {
-                                        name: "T"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                init {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "Get"
-                        object {
-                          identifier {
-                            name: "current_head"
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                is_returned: false
-              }
-            }
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "set_next"
-                        object {
-                          operator {
-                            op: Deref
-                            arguments {
-                              call {
-                                function {
-                                  simple_member_access {
-                                    field: "Get"
-                                    object {
-                                      identifier {
-                                        name: "v_wrapped"
-                                      }
-                                    }
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "current_head"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "set_prev"
-                        object {
-                          operator {
-                            op: Deref
-                            arguments {
-                              identifier {
-                                name: "current_head_value"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          identifier {
-                            name: "v_wrapped"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "head"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  identifier {
-                    name: "v_wrapped"
-                  }
-                }
-                op: Plain
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Clear"
-          }
-          self_pattern {
-            addr_pattern {
-              binding_pattern {
-                name: "self"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "Self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              if_statement {
-                condition {
-                  operator {
-                    op: Eq
-                    arguments {
-                      simple_member_access {
-                        field: "len"
-                        object {
-                          operator {
-                            op: Deref
-                            arguments {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-                then_block {
-                  statements {
-                    return_expression_statement {
-                      is_omitted_expression: true
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              variable_definition {
-                pattern {
-                  binding_pattern {
-                    name: "iter"
-                    type {
-                      auto_pattern {
-                      }
-                    }
-                  }
-                }
-                init {
-                  simple_member_access {
-                    field: "head"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                is_returned: false
-              }
-            }
-            statements {
-              while_statement {
-                condition {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "HasValue"
-                        object {
-                          identifier {
-                            name: "iter"
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                body {
-                  statements {
-                    variable_definition {
-                      pattern {
-                        binding_pattern {
-                          name: "current"
-                          type {
-                            auto_pattern {
-                            }
-                          }
-                        }
-                      }
-                      init {
-                        identifier {
-                          name: "iter"
-                        }
-                      }
-                      is_returned: false
-                    }
-                  }
-                  statements {
-                    assign {
-                      lhs {
-                        identifier {
-                          name: "iter"
-                        }
-                      }
-                      rhs {
-                        simple_member_access {
-                          field: "next"
-                          object {
-                            operator {
-                              op: Deref
-                              arguments {
-                                call {
-                                  function {
-                                    simple_member_access {
-                                      field: "Get"
-                                      object {
-                                        identifier {
-                                          name: "iter"
-                                        }
-                                      }
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      op: Plain
-                    }
-                  }
-                  statements {
-                    expression_statement {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Delete"
-                              object {
-                                identifier {
-                                  name: "heap"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                              fields {
-                                call {
-                                  function {
-                                    simple_member_access {
-                                      field: "Get"
-                                      object {
-                                        identifier {
-                                          name: "current"
-                                        }
-                                      }
-                                    }
-                                  }
-                                  argument {
-                                    tuple_literal {
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "head"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "CreateEmpty"
-                        object {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                op: Plain
-              }
-            }
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "tail"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  call {
-                    function {
-                      simple_member_access {
-                        field: "CreateEmpty"
-                        object {
-                          call {
-                            function {
-                              identifier {
-                                name: "Optional"
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  operator {
-                                    op: Ptr
-                                    arguments {
-                                      call {
-                                        function {
-                                          identifier {
-                                            name: "Node"
-                                          }
-                                        }
-                                        argument {
-                                          tuple_literal {
-                                            fields {
-                                              identifier {
-                                                name: "T"
-                                              }
-                                            }
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                      }
-                    }
-                  }
-                }
-                op: Plain
-              }
-            }
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "len"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  int_literal {
-                    value: 0
-                  }
-                }
-                op: Plain
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Length"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "len"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "head"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Optional"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          operator {
-                            op: Ptr
-                            arguments {
-                              call {
-                                function {
-                                  identifier {
-                                    name: "Node"
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                    fields {
-                                      identifier {
-                                        name: "T"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "tail"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Optional"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          operator {
-                            op: Ptr
-                            arguments {
-                              call {
-                                function {
-                                  identifier {
-                                    name: "Node"
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                    fields {
-                                      identifier {
-                                        name: "T"
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "len"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "GetListEntryByIndex"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "list"
-            type {
-              expression_pattern {
-                expression {
-                  operator {
-                    op: Ptr
-                    arguments {
-                      call {
-                        function {
-                          identifier {
-                            name: "LinkedList"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              identifier {
-                                name: "T"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "target_index"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          call {
-            function {
-              identifier {
-                name: "Optional"
-              }
-            }
-            argument {
-              tuple_literal {
-                fields {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "list_length"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Length"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "list"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Or
-                arguments {
-                  operator {
-                    op: Greater
-                    arguments {
-                      identifier {
-                        name: "target_index"
-                      }
-                    }
-                    arguments {
-                      operator {
-                        op: Sub
-                        arguments {
-                          identifier {
-                            name: "list_length"
-                          }
-                        }
-                        arguments {
-                          int_literal {
-                            value: 1
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Less
-                    arguments {
-                      identifier {
-                        name: "target_index"
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    call {
-                      function {
-                        simple_member_access {
-                          field: "CreateEmpty"
-                          object {
-                            call {
-                              function {
-                                identifier {
-                                  name: "Optional"
-                                }
-                              }
-                              argument {
-                                tuple_literal {
-                                  fields {
-                                    identifier {
-                                      name: "T"
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "search_backwards"
-                type {
-                  expression_pattern {
-                    expression {
-                      bool_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: Greater
-                arguments {
-                  identifier {
-                    name: "target_index"
-                  }
-                }
-                arguments {
-                  operator {
-                    op: Div
-                    arguments {
-                      identifier {
-                        name: "list_length"
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "iter"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Optional"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              operator {
-                                op: Ptr
-                                arguments {
-                                  call {
-                                    function {
-                                      identifier {
-                                        name: "Node"
-                                      }
-                                    }
-                                    argument {
-                                      tuple_literal {
-                                        fields {
-                                          identifier {
-                                            name: "T"
-                                          }
-                                        }
-                                      }
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              if_expression {
-                condition {
-                  identifier {
-                    name: "search_backwards"
-                  }
-                }
-                then_expression {
-                  simple_member_access {
-                    field: "tail"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "list"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                else_expression {
-                  simple_member_access {
-                    field: "head"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "list"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "c"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              if_expression {
-                condition {
-                  identifier {
-                    name: "search_backwards"
-                  }
-                }
-                then_expression {
-                  operator {
-                    op: Sub
-                    arguments {
-                      identifier {
-                        name: "list_length"
-                      }
-                    }
-                    arguments {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-                else_expression {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          while_statement {
-            condition {
-              operator {
-                op: NotEq
-                arguments {
-                  identifier {
-                    name: "c"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "target_index"
-                  }
-                }
-              }
-            }
-            body {
-              statements {
-                variable_definition {
-                  pattern {
-                    binding_pattern {
-                      name: "node"
-                      type {
-                        expression_pattern {
-                          expression {
-                            call {
-                              function {
-                                identifier {
-                                  name: "Node"
-                                }
-                              }
-                              argument {
-                                tuple_literal {
-                                  fields {
-                                    identifier {
-                                      name: "T"
-                                    }
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  init {
-                    operator {
-                      op: Deref
-                      arguments {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "Get"
-                              object {
-                                identifier {
-                                  name: "iter"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  is_returned: false
-                }
-              }
-              statements {
-                if_statement {
-                  condition {
-                    identifier {
-                      name: "search_backwards"
-                    }
-                  }
-                  then_block {
-                    statements {
-                      assign {
-                        lhs {
-                          identifier {
-                            name: "c"
-                          }
-                        }
-                        rhs {
-                          operator {
-                            op: Sub
-                            arguments {
-                              identifier {
-                                name: "c"
-                              }
-                            }
-                            arguments {
-                              int_literal {
-                                value: 1
-                              }
-                            }
-                          }
-                        }
-                        op: Plain
-                      }
-                    }
-                    statements {
-                      assign {
-                        lhs {
-                          identifier {
-                            name: "iter"
-                          }
-                        }
-                        rhs {
-                          simple_member_access {
-                            field: "prev"
-                            object {
-                              identifier {
-                                name: "node"
-                              }
-                            }
-                          }
-                        }
-                        op: Plain
-                      }
-                    }
-                  }
-                  else_block {
-                    statements {
-                      assign {
-                        lhs {
-                          identifier {
-                            name: "iter"
-                          }
-                        }
-                        rhs {
-                          simple_member_access {
-                            field: "next"
-                            object {
-                              identifier {
-                                name: "node"
-                              }
-                            }
-                          }
-                        }
-                        op: Plain
-                      }
-                    }
-                    statements {
-                      assign {
-                        lhs {
-                          identifier {
-                            name: "c"
-                          }
-                        }
-                        rhs {
-                          operator {
-                            op: Add
-                            arguments {
-                              identifier {
-                                name: "c"
-                              }
-                            }
-                            arguments {
-                              int_literal {
-                                value: 1
-                              }
-                            }
-                          }
-                        }
-                        op: Plain
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              simple_member_access {
-                field: "value"
-                object {
-                  operator {
-                    op: Deref
-                    arguments {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "Get"
-                            object {
-                              identifier {
-                                name: "iter"
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "test_list"
-                type {
-                  auto_pattern {
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Create"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "LinkedList"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              string_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushBack"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "This is a String Entry 0"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushBack"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "This is a String Entry 1"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushBack"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "This is a String Entry 2"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushBack"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "This is a String Entry 3"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushBack"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "This is a String Entry 4"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushBack"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "This is a String Entry 5"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushFront"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "This is a prepended String -1"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "String list length is: {0}"
-                      }
-                    }
-                    fields {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "Length"
-                            object {
-                              identifier {
-                                name: "test_list"
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "search_index"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 5
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "retrieved_entry"
-                type {
-                  auto_pattern {
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  identifier {
-                    name: "GetListEntryByIndex"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      operator {
-                        op: AddressOf
-                        arguments {
-                          identifier {
-                            name: "test_list"
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      identifier {
-                        name: "search_index"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          if_statement {
-            condition {
-              call {
-                function {
-                  simple_member_access {
-                    field: "HasValue"
-                    object {
-                      identifier {
-                        name: "retrieved_entry"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                variable_definition {
-                  pattern {
-                    binding_pattern {
-                      name: "retrieved_value"
-                      type {
-                        expression_pattern {
-                          expression {
-                            string_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  init {
-                    call {
-                      function {
-                        simple_member_access {
-                          field: "Get"
-                          object {
-                            identifier {
-                              name: "retrieved_entry"
-                            }
-                          }
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                        }
-                      }
-                    }
-                  }
-                  is_returned: false
-                }
-              }
-              statements {
-                expression_statement {
-                  expression {
-                    call {
-                      function {
-                        identifier {
-                          name: "Print"
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                          fields {
-                            identifier {
-                              name: "retrieved_value"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            else_block {
-              statements {
-                expression_statement {
-                  expression {
-                    call {
-                      function {
-                        identifier {
-                          name: "Print"
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                          fields {
-                            string_literal {
-                              value: "No entry found in String list for index {0}!"
-                            }
-                          }
-                          fields {
-                            identifier {
-                              name: "search_index"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Clear"
-                    object {
-                      identifier {
-                        name: "test_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "second_list"
-                type {
-                  auto_pattern {
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Create"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "LinkedList"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              operator {
-                                op: Ptr
-                                arguments {
-                                  int_type_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "number"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 1337
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "number_ptr"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: AddressOf
-                arguments {
-                  identifier {
-                    name: "number"
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "PushBack"
-                    object {
-                      identifier {
-                        name: "second_list"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "number_ptr"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "retrieved_ptr"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          int_type_literal {
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Get"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "GetListEntryByIndex"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              operator {
-                                op: AddressOf
-                                arguments {
-                                  identifier {
-                                    name: "second_list"
-                                  }
-                                }
-                              }
-                            }
-                            fields {
-                              int_literal {
-                                value: 0
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "value"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: Deref
-                arguments {
-                  identifier {
-                    name: "retrieved_ptr"
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "Print"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      string_literal {
-                        value: "Value {0}"
-                      }
-                    }
-                    fields {
-                      identifier {
-                        name: "value"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1bb31799f794a026275be18fd889f8917257b7a6

@@ -1,73 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    variable {
-      binding {
-        name: "x"
-        type {
-          expression_pattern {
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-      initializer {
-        int_literal {
-          value: 0
-        }
-      }
-    }
-  }
-  declarations {
-    variable {
-      binding {
-        name: "x"
-        type {
-          expression_pattern {
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-      initializer {
-        int_literal {
-          value: 0
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1c15b9ff3704bb9603866c7a06a3070eb8aacc69

@@ -1,89 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "n"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 0
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          match {
-            expression {
-              identifier {
-                name: "n"
-              }
-            }
-            clauses {
-              pattern {
-                expression_pattern {
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1c2582d7495e080fa022962c6ed26fd62760e88e

@@ -1,404 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "MyHashable"
-      }
-      members {
-        let {
-          pattern {
-            generic_binding {
-              name: "Result"
-              type {
-                type_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Hash"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Result"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    constraint {
-      name {
-        name: "HashToIntConvertible"
-      }
-      members {
-        interface_impl {
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          constraint {
-            identifier {
-              name: "MyHashable"
-            }
-          }
-        }
-      }
-      members {
-        interface_impl {
-          impl_type {
-            compound_member_access {
-              object {
-                identifier {
-                  name: "Self"
-                }
-              }
-              path {
-                simple_member_access {
-                  field: "Result"
-                  object {
-                    identifier {
-                      name: "MyHashable"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          constraint {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "MyHashValue"
-      }
-      members {
-        impl {
-          kind: ExternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Convert"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      int_literal {
-                        value: 4
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Widget"
-      }
-      members {
-        impl {
-          kind: ExternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            where {
-              base {
-                identifier {
-                  name: "MyHashable"
-                }
-              }
-              clauses {
-                rewrite {
-                  member_name: "Result"
-                  replacement {
-                    identifier {
-                      name: "MyHashValue"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Hash"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  identifier {
-                    name: "MyHashValue"
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      struct_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "MakeSmallHash"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          identifier {
-            name: "HashToIntConvertible"
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  compound_member_access {
-                    object {
-                      identifier {
-                        name: "x"
-                      }
-                    }
-                    path {
-                      simple_member_access {
-                        field: "Hash"
-                        object {
-                          identifier {
-                            name: "MyHashable"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "w"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Widget"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "MakeSmallHash"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "w"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1c37ed06bf8776ee0d165e3ed3d8833a4cc9c760

@@ -1,190 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        destructor {
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "DESTRUCTOR A1 {0}"
-                          }
-                        }
-                        fields {
-                          simple_member_access {
-                            field: "n"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        destructor {
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              expression_statement {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "Print"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          string_literal {
-                            value: "DESTRUCTOR A2 {0}"
-                          }
-                        }
-                        fields {
-                          simple_member_access {
-                            field: "n"
-                            object {
-                              identifier {
-                                name: "self"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "n"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "n"
-                  expression {
-                    int_literal {
-                      value: 3
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1c452ac633219d656ab5904d7638e5379e44a582

@@ -1,131 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            call {
-              function {
-                identifier {
-                  name: "ImplicitAs"
-                }
-              }
-              argument {
-                tuple_literal {
-                  fields {
-                    int_type_literal {
-                    }
-                  }
-                }
-              }
-            }
-          }
-          members {
-            function {
-              name {
-                name: "Convert"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      int_literal {
-                        value: 42
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "a"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1ceaf07b219a9004798ecc0856af9b0d10cce19c

@@ -1,781 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Vector"
-      }
-      members {
-        function {
-          name {
-            name: "Zero"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Scale"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "v"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "Self"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        call {
-          function {
-            identifier {
-              name: "Point"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      interface {
-        identifier {
-          name: "Vector"
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Zero"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Add"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    call {
-                      function {
-                        identifier {
-                          name: "Point"
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                          fields {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "b"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "b"
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Scale"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    call {
-                      function {
-                        identifier {
-                          name: "Point"
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                          fields {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "v"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Point"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        operator {
-                          op: Mul
-                          arguments {
-                            simple_member_access {
-                              field: "x"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            identifier {
-                              name: "v"
-                            }
-                          }
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        operator {
-                          op: Mul
-                          arguments {
-                            simple_member_access {
-                              field: "y"
-                              object {
-                                identifier {
-                                  name: "self"
-                                }
-                              }
-                            }
-                          }
-                          arguments {
-                            identifier {
-                              name: "v"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "AddAndScaleGeneric"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          identifier {
-            name: "Vector"
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "s"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          identifier {
-            name: "T"
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Scale"
-                    object {
-                      call {
-                        function {
-                          simple_member_access {
-                            field: "Add"
-                            object {
-                              identifier {
-                                name: "a"
-                              }
-                            }
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              call {
-                                function {
-                                  simple_member_access {
-                                    field: "Zero"
-                                    object {
-                                      identifier {
-                                        name: "T"
-                                      }
-                                    }
-                                  }
-                                }
-                                argument {
-                                  tuple_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "s"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "x"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-                fields {
-                  name: "y"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  identifier {
-                    name: "AddAndScaleGeneric"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "a"
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 5
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Sub
-                arguments {
-                  simple_member_access {
-                    field: "x"
-                    object {
-                      identifier {
-                        name: "p"
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 10
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1d0d6abe9b8f6cf6eab4083ea51891c7b09b5653

@@ -1,187 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "Foo"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "A"
-      }
-      members {
-        function {
-          name {
-            name: "F"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "X"
-      }
-      members {
-        impl {
-          kind: InternalImpl
-          impl_type {
-            identifier {
-              name: "Self"
-            }
-          }
-          interface {
-            identifier {
-              name: "A"
-            }
-          }
-          members {
-            function {
-              name {
-                name: "F"
-              }
-              self_pattern {
-                binding_pattern {
-                  name: "self"
-                  type {
-                    expression_pattern {
-                      expression {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              param_pattern {
-              }
-              return_term {
-                kind: Expression
-                type {
-                  int_type_literal {
-                  }
-                }
-              }
-              body {
-                statements {
-                  return_expression_statement {
-                    expression {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "X"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  compound_member_access {
-                    object {
-                      identifier {
-                        name: "a"
-                      }
-                    }
-                    path {
-                      compound_member_access {
-                        object {
-                          identifier {
-                            name: "X"
-                          }
-                        }
-                        path {
-                          simple_member_access {
-                            field: "F"
-                            object {
-                              identifier {
-                                name: "A"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1d36375d17078164cf9329dbe7f4b539b5323f34

@@ -1,62 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        qualifiers: "F"
-        name: "G"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1e15985570e0b52f0d40a19e90b53ab6c679729d

@@ -1,650 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    choice {
-      name {
-        name: "Opt"
-      }
-      alternatives {
-        name: "None"
-        signature {
-        }
-      }
-      alternatives {
-        name: "Some"
-        signature {
-          fields {
-            int_type_literal {
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "A"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "Opt"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "Opt"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          match {
-            expression {
-              tuple_literal {
-                fields {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                fields {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    alternative_pattern {
-                      choice_type {
-                        identifier {
-                          name: "Opt"
-                        }
-                      }
-                      alternative_name: "Some"
-                      arguments {
-                        fields {
-                          binding_pattern {
-                            name: "n"
-                            type {
-                              expression_pattern {
-                                expression {
-                                  int_type_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        auto_pattern {
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        identifier {
-                          name: "n"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        auto_pattern {
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    alternative_pattern {
-                      choice_type {
-                        identifier {
-                          name: "Opt"
-                        }
-                      }
-                      alternative_name: "Some"
-                      arguments {
-                        fields {
-                          binding_pattern {
-                            name: "n"
-                            type {
-                              expression_pattern {
-                                expression {
-                                  int_type_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        identifier {
-                          name: "n"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                expression_pattern {
-                  expression {
-                    tuple_literal {
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "None"
-                              object {
-                                identifier {
-                                  name: "Opt"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                      fields {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "None"
-                              object {
-                                identifier {
-                                  name: "Opt"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "B"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "Opt"
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "Opt"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          match {
-            expression {
-              tuple_literal {
-                fields {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                fields {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "None"
-                              object {
-                                identifier {
-                                  name: "Opt"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "_"
-                      type {
-                        auto_pattern {
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    alternative_pattern {
-                      choice_type {
-                        identifier {
-                          name: "Opt"
-                        }
-                      }
-                      alternative_name: "Some"
-                      arguments {
-                        fields {
-                          binding_pattern {
-                            name: "n"
-                            type {
-                              expression_pattern {
-                                expression {
-                                  int_type_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        call {
-                          function {
-                            simple_member_access {
-                              field: "None"
-                              object {
-                                identifier {
-                                  name: "Opt"
-                                }
-                              }
-                            }
-                          }
-                          argument {
-                            tuple_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        identifier {
-                          name: "n"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    alternative_pattern {
-                      choice_type {
-                        identifier {
-                          name: "Opt"
-                        }
-                      }
-                      alternative_name: "Some"
-                      arguments {
-                        fields {
-                          binding_pattern {
-                            name: "n"
-                            type {
-                              expression_pattern {
-                                expression {
-                                  int_type_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    alternative_pattern {
-                      choice_type {
-                        identifier {
-                          name: "Opt"
-                        }
-                      }
-                      alternative_name: "Some"
-                      arguments {
-                        fields {
-                          binding_pattern {
-                            name: "m"
-                            type {
-                              expression_pattern {
-                                expression {
-                                  int_type_literal {
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        operator {
-                          op: Add
-                          arguments {
-                            identifier {
-                              name: "n"
-                            }
-                          }
-                          arguments {
-                            identifier {
-                              name: "m"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Add
-                arguments {
-                  call {
-                    function {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          call {
-                            function {
-                              simple_member_access {
-                                field: "None"
-                                object {
-                                  identifier {
-                                    name: "Opt"
-                                  }
-                                }
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                              }
-                            }
-                          }
-                        }
-                        fields {
-                          call {
-                            function {
-                              simple_member_access {
-                                field: "Some"
-                                object {
-                                  identifier {
-                                    name: "Opt"
-                                  }
-                                }
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  int_literal {
-                                    value: 1
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  call {
-                    function {
-                      identifier {
-                        name: "B"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          call {
-                            function {
-                              simple_member_access {
-                                field: "Some"
-                                object {
-                                  identifier {
-                                    name: "Opt"
-                                  }
-                                }
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                                fields {
-                                  int_literal {
-                                    value: 2
-                                  }
-                                }
-                              }
-                            }
-                          }
-                        }
-                        fields {
-                          call {
-                            function {
-                              simple_member_access {
-                                field: "None"
-                                object {
-                                  identifier {
-                                    name: "Opt"
-                                  }
-                                }
-                              }
-                            }
-                            argument {
-                              tuple_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1e43eb0a0f7b622f2ee5153aadeba3c2716c3b0a

@@ -1,98 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Vector"
-      }
-      members {
-        function {
-          name {
-            name: "Zero"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: InternalImpl
-      impl_type {
-        string_literal {
-          value: "hello"
-        }
-      }
-      interface {
-        identifier {
-          name: "Vector"
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Zero"
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1e4fb57739ad776cee50880a79f29cdc6b532a58

@@ -1,370 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    interface {
-      name {
-        name: "B"
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        call {
-          function {
-            identifier {
-              name: "A"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                identifier {
-                  name: "T"
-                }
-              }
-            }
-          }
-        }
-      }
-      interface {
-        call {
-          function {
-            identifier {
-              name: "B"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: ExternalImpl
-      impl_type {
-        call {
-          function {
-            identifier {
-              name: "A"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      interface {
-        call {
-          function {
-            identifier {
-              name: "B"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                identifier {
-                  name: "T"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          call {
-            function {
-              identifier {
-                name: "B"
-              }
-            }
-            argument {
-              tuple_literal {
-                fields {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "G"
-      }
-      deduced_parameters {
-        name: "T"
-        type {
-          call {
-            function {
-              identifier {
-                name: "B"
-              }
-            }
-            argument {
-              tuple_literal {
-                fields {
-                  bool_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Omitted
-      }
-      body {
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "A"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              bool_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "A"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "a"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "G"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "b"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "F"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "b"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1ea21248974dcd55d90a60ca12e8149169a9b34c

@@ -1,747 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Cell"
-      }
-      members {
-        function {
-          name {
-            name: "Create"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Cell"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "data"
-                      expression {
-                        identifier {
-                          name: "x"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Get"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "T"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "data"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Put"
-          }
-          self_pattern {
-            addr_pattern {
-              binding_pattern {
-                name: "self"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "Self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "data"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                op: Plain
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Update"
-          }
-          deduced_parameters {
-            name: "U"
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "ImplicitAs"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          self_pattern {
-            addr_pattern {
-              binding_pattern {
-                name: "self"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "Self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "U"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Omitted
-          }
-          body {
-            statements {
-              assign {
-                lhs {
-                  simple_member_access {
-                    field: "data"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "self"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                rhs {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                op: Plain
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "CreateOther"
-          }
-          deduced_parameters {
-            name: "U"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "U"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Cell"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "U"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "data"
-                      expression {
-                        identifier {
-                          name: "x"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "data"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "Integer"
-      }
-      members {
-        variable {
-          binding {
-            name: "int"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "i"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Integer"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "int"
-                  expression {
-                    int_literal {
-                      value: 1
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "c"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Cell"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              identifier {
-                                name: "Integer"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Create"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "Cell"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              identifier {
-                                name: "Integer"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "i"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          assign {
-            lhs {
-              identifier {
-                name: "i"
-              }
-            }
-            rhs {
-              struct_literal {
-                fields {
-                  name: "int"
-                  expression {
-                    int_literal {
-                      value: 2
-                    }
-                  }
-                }
-              }
-            }
-            op: Plain
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "j"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "Integer"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Get"
-                    object {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Put"
-                    object {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "i"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Update"
-                    object {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "j"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "d"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Cell"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              identifier {
-                                name: "Integer"
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "CreateOther"
-                    object {
-                      identifier {
-                        name: "c"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "i"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Add
-                arguments {
-                  simple_member_access {
-                    field: "int"
-                    object {
-                      simple_member_access {
-                        field: "data"
-                        object {
-                          identifier {
-                            name: "c"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  simple_member_access {
-                    field: "int"
-                    object {
-                      simple_member_access {
-                        field: "data"
-                        object {
-                          identifier {
-                            name: "d"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1eb37a662ac6fc2c01dc9b5b1317e9bdc7ce64ec

@@ -1,132 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "AddInt"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "a"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "b"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "ret"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: Add
-                arguments {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            is_returned: true
-          }
-        }
-        statements {
-          return_var_statement {
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  identifier {
-                    name: "AddInt"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 1
-                      }
-                    }
-                    fields {
-                      int_literal {
-                        value: 2
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1f137378f423a375a57448370eceee7aaac663ec

@@ -1,99 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "ComputeSum"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Auto
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Sub
-                arguments {
-                  call {
-                    function {
-                      identifier {
-                        name: "ComputeSum"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          int_literal {
-                            value: 1
-                          }
-                        }
-                        fields {
-                          int_literal {
-                            value: 2
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 3
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1fb3cabbe7b1d1db38a57e533dd8047bf828a338

@@ -1,86 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "F"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  call {
-                    function {
-                      identifier {
-                        name: "F"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          int_literal {
-                            value: 0
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          type_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "x"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1fcb05bd7ceeb20c92c134283274f611d58184be

@@ -1,292 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "Point"
-      }
-      members {
-        function {
-          name {
-            name: "Origin"
-          }
-          param_pattern {
-            fields {
-              binding_pattern {
-                name: "zero"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return_term {
-            kind: Expression
-            type {
-              call {
-                function {
-                  identifier {
-                    name: "Self"
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      identifier {
-                        name: "T"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  struct_literal {
-                    fields {
-                      name: "x"
-                      expression {
-                        identifier {
-                          name: "zero"
-                        }
-                      }
-                    }
-                    fields {
-                      name: "y"
-                      expression {
-                        identifier {
-                          name: "zero"
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "GetX"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    call {
-                      function {
-                        identifier {
-                          name: "Self"
-                        }
-                      }
-                      argument {
-                        tuple_literal {
-                          fields {
-                            identifier {
-                              name: "T"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              identifier {
-                name: "T"
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  simple_member_access {
-                    field: "x"
-                    object {
-                      identifier {
-                        name: "self"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        variable {
-          binding {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "T"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      type_params {
-        fields {
-          generic_binding {
-            name: "T"
-            type {
-              type_type_literal {
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "p"
-                type {
-                  expression_pattern {
-                    expression {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Origin"
-                    object {
-                      call {
-                        function {
-                          identifier {
-                            name: "Point"
-                          }
-                        }
-                        argument {
-                          tuple_literal {
-                            fields {
-                              int_type_literal {
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                    fields {
-                      int_literal {
-                        value: 0
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "GetX"
-                    object {
-                      identifier {
-                        name: "p"
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/1ff7462970b50e872fa525ce63c82deb12e251ad

@@ -1,56 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "x"
-                type {
-                  expression_pattern {
-                    expression {
-                      int_type_literal {
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              int_literal {
-                value: 0
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              identifier {
-                name: "x"
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/2123f77e8516358c52163a4fa1627361f3513f30

@@ -1,56 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "C"
-      }
-      members {
-        variable {
-          binding {
-            name: "m"
-            type {
-              expression_pattern {
-                expression {
-                  identifier {
-                    name: "Self"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/21df195c24c357e5a8f18f482090d95d2524e548

@@ -1,199 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-    }
-  }
-  declarations {
-    class_declaration {
-      name {
-        name: "B"
-      }
-      members {
-        function {
-          name {
-            name: "Foo"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  int_literal {
-                    value: 0
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "b"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "B"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-                fields {
-                  name: "base"
-                  expression {
-                    struct_literal {
-                    }
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "bp"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "B"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              operator {
-                op: AddressOf
-                arguments {
-                  identifier {
-                    name: "b"
-                  }
-                }
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "ap"
-                type {
-                  expression_pattern {
-                    expression {
-                      operator {
-                        op: Ptr
-                        arguments {
-                          identifier {
-                            name: "A"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              identifier {
-                name: "bp"
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              call {
-                function {
-                  simple_member_access {
-                    field: "Foo"
-                    object {
-                      operator {
-                        op: Deref
-                        arguments {
-                          identifier {
-                            name: "ap"
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                argument {
-                  tuple_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/226b4ae2606b0af76ab25c51d0d61f3fa3b04228

@@ -1,63 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          if_statement {
-            condition {
-              operator {
-                op: Eq
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-            then_block {
-              statements {
-                return_expression_statement {
-                  expression {
-                    int_literal {
-                      value: 0
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/2291d3e5898c9c430cc6ecf3855f87bcae68cfbc

@@ -1,48 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    interface {
-      name {
-        name: "Vector"
-      }
-      members {
-        interface_extend {
-          base {
-            int_type_literal {
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 0
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/230ea69eab009635a68f253a70e7f55d8af387bd

@@ -1,264 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    class_declaration {
-      name {
-        name: "A"
-      }
-    }
-  }
-  declarations {
-    impl {
-      kind: InternalImpl
-      impl_type {
-        identifier {
-          name: "A"
-        }
-      }
-      interface {
-        call {
-          function {
-            identifier {
-              name: "ImplicitAs"
-            }
-          }
-          argument {
-            tuple_literal {
-              fields {
-                int_type_literal {
-                }
-              }
-            }
-          }
-        }
-      }
-      members {
-        function {
-          name {
-            name: "Convert"
-          }
-          self_pattern {
-            binding_pattern {
-              name: "self"
-              type {
-                expression_pattern {
-                  expression {
-                    identifier {
-                      name: "Self"
-                    }
-                  }
-                }
-              }
-            }
-          }
-          param_pattern {
-          }
-          return_term {
-            kind: Expression
-            type {
-              int_type_literal {
-              }
-            }
-          }
-          body {
-            statements {
-              return_expression_statement {
-                expression {
-                  int_literal {
-                    value: 1
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          variable_definition {
-            pattern {
-              binding_pattern {
-                name: "a"
-                type {
-                  expression_pattern {
-                    expression {
-                      identifier {
-                        name: "A"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            init {
-              struct_literal {
-              }
-            }
-            is_returned: false
-          }
-        }
-        statements {
-          match {
-            expression {
-              tuple_literal {
-                fields {
-                  identifier {
-                    name: "a"
-                  }
-                }
-                fields {
-                  identifier {
-                    name: "a"
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    expression_pattern {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    binding_pattern {
-                      name: "n"
-                      type {
-                        expression_pattern {
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                tuple_pattern {
-                  fields {
-                    binding_pattern {
-                      name: "n"
-                      type {
-                        expression_pattern {
-                          expression {
-                            int_type_literal {
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                  fields {
-                    expression_pattern {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            clauses {
-              pattern {
-                expression_pattern {
-                  expression {
-                    tuple_literal {
-                      fields {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                      fields {
-                        int_literal {
-                          value: 1
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              statement {
-                block {
-                  statements {
-                    return_expression_statement {
-                      expression {
-                        int_literal {
-                          value: 0
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        statements {
-          return_expression_statement {
-            expression {
-              int_literal {
-                value: 1
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

explorer/fuzzing/fuzzer_corpus/2345f2c6add76c7aa04327e5aaa0840275740385

@@ -1,124 +0,0 @@
-compilation_unit {
-  package_statement {
-    package_name: "ExplorerTest"
-  }
-  is_api: true
-  declarations {
-    function {
-      name {
-        name: "f"
-      }
-      param_pattern {
-        fields {
-          binding_pattern {
-            name: "x"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-        fields {
-          binding_pattern {
-            name: "y"
-            type {
-              expression_pattern {
-                expression {
-                  int_type_literal {
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Add
-                arguments {
-                  identifier {
-                    name: "x"
-                  }
-                }
-                arguments {
-                  identifier {
-                    name: "y"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  declarations {
-    function {
-      name {
-        name: "Main"
-      }
-      param_pattern {
-      }
-      return_term {
-        kind: Expression
-        type {
-          int_type_literal {
-          }
-        }
-      }
-      body {
-        statements {
-          return_expression_statement {
-            expression {
-              operator {
-                op: Sub
-                arguments {
-                  call {
-                    function {
-                      identifier {
-                        name: "f"
-                      }
-                    }
-                    argument {
-                      tuple_literal {
-                        fields {
-                          int_literal {
-                            value: 2
-                          }
-                        }
-                        fields {
-                          int_literal {
-                            value: 3
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                arguments {
-                  int_literal {
-                    value: 5
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}